diff --git "a/jsonl/T090_turing_machine_grid_transition-data-generator.jsonl" "b/jsonl/T090_turing_machine_grid_transition-data-generator.jsonl"
--- "a/jsonl/T090_turing_machine_grid_transition-data-generator.jsonl"
+++ "b/jsonl/T090_turing_machine_grid_transition-data-generator.jsonl"
@@ -1,5000 +1,5000 @@
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000000/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 0}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000001/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000002/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000003/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000004/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000005/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 5}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000006/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 6}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000007/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 7}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000008/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 8}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000009/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 9}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000010/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 10}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000011/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 11}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000012/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 12}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000013/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 13}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000014/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 14}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000015/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 15}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000016/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 16}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000017/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 17}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000018/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 18}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000019/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 19}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000020/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 20}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000021/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 21}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000022/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 22}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000023/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 23}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000024/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 24}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000025/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 25}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000026/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 26}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000027/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 27}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000028/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 28}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000029/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 29}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000030/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 30}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000031/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 31}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000032/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 32}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000033/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 33}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000034/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 34}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000035/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 35}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000036/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 36}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000037/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 37}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000038/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 38}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000039/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 39}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000040/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 40}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000041/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 41}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000042/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 42}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000043/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 43}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000044/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 44}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000045/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 45}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000046/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 46}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000047/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 47}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000048/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 48}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000049/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 49}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000050/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 50}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000051/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 51}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000052/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 52}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000053/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 53}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000054/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 54}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000055/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 55}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000056/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 56}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000057/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 57}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000058/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 58}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000059/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 59}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000060/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 60}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000061/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 61}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000062/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 62}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000063/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 63}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000064/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 64}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000065/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 65}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000066/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 66}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000067/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 67}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000068/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 68}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000069/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 69}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000070/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 70}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000071/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 71}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000072/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 72}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000073/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 73}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000074/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 74}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000075/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 75}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000076/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 76}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000077/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 77}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000078/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 78}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000079/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 79}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000080/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 80}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000081/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 81}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000082/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 82}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000083/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 83}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000084/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 84}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000085/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 85}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000086/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 86}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000087/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 87}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000088/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 88}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000089/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 89}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000090/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 90}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000091/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 91}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000092/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 92}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000093/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 93}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000094/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 94}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000095/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 95}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000096/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 96}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000097/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 97}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000098/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 98}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000099/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 99}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000100/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 100}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000101/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 101}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000102/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 102}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000103/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 103}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000104/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 104}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000105/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 105}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000106/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 106}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000107/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 107}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000108/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 108}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000109/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 109}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000110/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 110}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000111/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 111}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000112/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 112}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000113/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 113}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000114/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 114}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000115/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 115}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000116/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 116}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000117/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 117}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000118/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 118}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000119/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 119}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000120/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 120}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000121/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 121}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000122/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 122}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000123/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 123}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000124/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 124}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000125/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 125}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000126/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 126}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000127/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 127}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000128/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 128}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000129/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 129}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000130/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 130}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000131/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 131}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000132/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 132}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000133/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 133}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000134/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 134}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000135/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 135}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000136/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 136}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000137/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 137}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000138/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 138}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000139/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 139}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000140/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 140}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000141/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 141}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000142/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 142}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000143/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 143}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000144/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 144}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000145/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 145}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000146/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 146}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000147/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 147}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000148/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 148}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000149/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 149}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000150/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 150}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000151/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 151}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000152/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 152}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000153/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 153}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000154/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 154}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000155/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 155}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000156/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 156}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000157/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 157}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000158/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 158}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000159/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 159}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000160/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 160}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000161/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 161}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000162/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 162}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000163/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 163}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000164/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 164}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000165/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 165}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000166/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 166}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000167/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 167}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000168/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 168}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000169/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 169}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000170/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 170}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000171/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 171}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000172/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 172}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000173/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 173}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000174/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 174}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000175/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 175}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000176/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 176}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000177/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 177}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000178/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 178}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000179/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 179}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000180/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 180}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000181/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 181}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000182/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 182}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000183/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 183}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000184/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 184}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000185/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 185}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000186/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 186}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000187/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 187}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000188/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 188}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000189/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 189}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000190/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 190}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000191/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 191}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000192/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 192}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000193/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 193}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000194/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 194}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000195/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 195}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000196/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 196}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000197/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 197}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000198/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 198}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000199/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 199}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000200/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 200}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000201/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 201}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000202/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 202}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000203/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 203}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000204/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 204}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000205/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 205}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000206/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 206}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000207/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 207}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000208/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 208}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000209/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 209}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000210/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 210}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000211/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 211}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000212/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 212}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000213/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 213}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000214/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 214}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000215/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 215}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000216/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 216}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000217/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 217}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000218/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 218}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000219/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 219}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000220/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 220}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000221/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 221}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000222/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 222}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000223/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 223}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000224/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 224}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000225/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 225}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000226/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 226}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000227/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 227}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000228/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 228}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000229/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 229}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000230/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 230}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000231/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 231}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000232/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 232}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000233/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 233}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000234/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 234}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000235/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 235}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000236/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 236}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000237/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 237}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000238/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 238}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000239/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 239}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000240/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 240}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000241/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 241}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000242/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 242}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000243/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 243}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000244/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 244}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000245/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 245}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000246/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 246}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000247/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 247}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000248/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 248}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000249/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 249}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000250/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 250}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000251/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 251}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000252/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 252}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000253/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 253}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000254/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 254}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000255/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 255}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000256/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 256}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000257/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 257}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000258/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 258}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000259/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 259}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000260/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 260}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000261/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 261}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000262/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 262}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000263/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 263}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000264/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 264}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000265/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 265}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000266/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 266}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000267/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 267}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000268/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 268}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000269/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 269}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000270/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 270}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000271/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 271}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000272/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 272}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000273/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 273}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000274/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 274}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000275/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 275}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000276/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 276}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000277/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 277}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000278/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 278}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000279/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 279}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000280/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 280}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000281/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 281}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000282/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 282}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000283/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 283}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000284/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 284}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000285/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 285}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000286/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 286}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000287/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 287}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000288/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 288}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000289/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 289}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000290/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 290}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000291/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 291}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000292/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 292}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000293/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 293}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000294/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 294}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000295/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 295}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000296/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 296}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000297/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 297}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000298/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 298}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000299/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 299}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000300/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 300}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000301/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 301}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000302/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 302}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000303/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 303}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000304/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 304}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000305/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 305}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000306/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 306}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000307/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 307}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000308/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 308}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000309/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 309}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000310/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 310}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000311/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 311}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000312/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 312}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000313/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 313}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000314/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 314}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000315/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 315}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000316/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 316}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000317/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 317}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000318/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 318}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000319/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 319}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000320/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 320}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000321/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 321}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000322/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 322}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000323/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 323}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000324/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 324}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000325/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 325}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000326/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, ��� — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 326}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000327/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 327}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000328/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 328}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000329/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 329}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000330/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 330}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000331/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 331}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000332/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 332}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000333/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 333}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000334/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 334}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000335/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 335}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000336/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 336}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000337/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 337}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000338/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 338}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000339/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 339}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000340/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 340}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000341/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 341}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000342/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 342}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000343/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 343}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000344/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 344}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000345/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 345}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000346/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 346}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000347/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 347}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000348/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 348}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000349/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 349}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000350/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 350}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000351/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 351}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000352/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 352}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000353/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 353}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000354/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 354}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000355/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 355}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000356/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 356}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000357/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 357}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000358/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 358}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000359/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 359}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000360/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 360}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000361/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 361}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000362/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 362}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000363/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 363}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000364/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 364}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000365/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 365}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000366/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 366}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000367/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 367}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000368/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 368}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000369/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 369}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000370/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 370}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000371/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 371}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000372/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 372}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000373/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 373}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000374/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 374}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000375/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 375}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000376/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 376}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000377/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 377}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000378/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 378}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000379/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 379}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000380/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 380}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000381/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 381}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000382/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 382}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000383/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 383}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000384/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 384}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000385/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 385}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000386/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 386}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000387/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 387}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000388/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … �� a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 388}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000389/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 389}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000390/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 390}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000391/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 391}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000392/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 392}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000393/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 393}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000394/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 394}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000395/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 395}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000396/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 396}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000397/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 397}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000398/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 398}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000399/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 399}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000400/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 400}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000401/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 401}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000402/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 402}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000403/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 403}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000404/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 404}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000405/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 405}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000406/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 406}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000407/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 407}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000408/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 408}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000409/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 409}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000410/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 410}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000411/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 411}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000412/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 412}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000413/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 413}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000414/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 414}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000415/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 415}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000416/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 416}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000417/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, ��� — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 417}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000418/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 418}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000419/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 419}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000420/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 420}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000421/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 421}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000422/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 422}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000423/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 423}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000424/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 424}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000425/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 425}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000426/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 426}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000427/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 427}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000428/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 428}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000429/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 429}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000430/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 430}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000431/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 431}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000432/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 432}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000433/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 433}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000434/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 434}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000435/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 435}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000436/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 436}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000437/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 437}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000438/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 438}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000439/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 439}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000440/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 440}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000441/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 441}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000442/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 442}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000443/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 443}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000444/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 444}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000445/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 445}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000446/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 446}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000447/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 447}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000448/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 448}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000449/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 449}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000450/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 450}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000451/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 451}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000452/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 452}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000453/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 453}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000454/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 454}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000455/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 455}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000456/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 456}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000457/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 457}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000458/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 458}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000459/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 459}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000460/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 460}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000461/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 461}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000462/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 462}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000463/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 463}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000464/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 464}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000465/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 465}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000466/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 466}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000467/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 467}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000468/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 468}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000469/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 469}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000470/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 470}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000471/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 471}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000472/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 472}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000473/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 473}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000474/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 474}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000475/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 475}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000476/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 476}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000477/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 477}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000478/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 478}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000479/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 479}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000480/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 480}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000481/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 481}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000482/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 482}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000483/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 483}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000484/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 484}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000485/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 485}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000486/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 486}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000487/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 487}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000488/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 488}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000489/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 489}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000490/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 490}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000491/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 491}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000492/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 492}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000493/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 493}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000494/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 494}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000495/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 495}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000496/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 496}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000497/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 497}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000498/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 498}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000499/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 499}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000500/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 500}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000501/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 501}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000502/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 502}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000503/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 503}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000504/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 504}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000505/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 505}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000506/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 506}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000507/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 507}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000508/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 508}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000509/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 509}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000510/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 510}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000511/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 511}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000512/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 512}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000513/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 513}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000514/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 514}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000515/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 515}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000516/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 516}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000517/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 517}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000518/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 518}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000519/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 519}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000520/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 520}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000521/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 521}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000522/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 522}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000523/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 523}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000524/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 524}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000525/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 525}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000526/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 526}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000527/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 527}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000528/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 528}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000529/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 529}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000530/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 530}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000531/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 531}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000532/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 532}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000533/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 533}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000534/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 534}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000535/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 535}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000536/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 536}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000537/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 537}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000538/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 538}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000539/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 539}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000540/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 540}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000541/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 541}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000542/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 542}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000543/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 543}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000544/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 544}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000545/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 545}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000546/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 546}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000547/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 547}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000548/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 548}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000549/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 549}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000550/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 550}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000551/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 551}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000552/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 552}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000553/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 553}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000554/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 554}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000555/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 555}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000556/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 556}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000557/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 557}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000558/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 558}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000559/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 559}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000560/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 560}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000561/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 561}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000562/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 562}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000563/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 563}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000564/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 564}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000565/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 565}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000566/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 566}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000567/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 567}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000568/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 568}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000569/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 569}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000570/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 570}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000571/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 571}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000572/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 572}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000573/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 573}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000574/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 574}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000575/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 575}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000576/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 576}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000577/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 577}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000578/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 578}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000579/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 579}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000580/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 580}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000581/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 581}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000582/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 582}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000583/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 583}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000584/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 584}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000585/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 585}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000586/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 586}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000587/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 587}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000588/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 588}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000589/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 589}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000590/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 590}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000591/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 591}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000592/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 592}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000593/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 593}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000594/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 594}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000595/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 595}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000596/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 596}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000597/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 597}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000598/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 598}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000599/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 599}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000600/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 600}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000601/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 601}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000602/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 602}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000603/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 603}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000604/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 604}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000605/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 605}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000606/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 606}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000607/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 607}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000608/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 608}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000609/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 609}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000610/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 610}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000611/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 611}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000612/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 612}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000613/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 613}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000614/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 614}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000615/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 615}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000616/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 616}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000617/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 617}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000618/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 618}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000619/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 619}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000620/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 620}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000621/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 621}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000622/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 622}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000623/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 623}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000624/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 624}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000625/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 625}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000626/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 626}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000627/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 627}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000628/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 628}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000629/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 629}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000630/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 630}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000631/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 631}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000632/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 632}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000633/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 633}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000634/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 634}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000635/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 635}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000636/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 636}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000637/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 637}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000638/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 638}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000639/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 639}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000640/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 640}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000641/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 641}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000642/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 642}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000643/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 643}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000644/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 644}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000645/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 645}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000646/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 646}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000647/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 647}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000648/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 648}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000649/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 649}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000650/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 650}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000651/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 651}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000652/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 652}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000653/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 653}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000654/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 654}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000655/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 655}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000656/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 656}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000657/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 657}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000658/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 658}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000659/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 659}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000660/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 660}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000661/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 661}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000662/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 662}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000663/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 663}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000664/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 664}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000665/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 665}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000666/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 666}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000667/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 667}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000668/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 668}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000669/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 669}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000670/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 670}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000671/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 671}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000672/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 672}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000673/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 673}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000674/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 674}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000675/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 675}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000676/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 676}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000677/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 677}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000678/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 678}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000679/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 679}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000680/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 680}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000681/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 681}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000682/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 682}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000683/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 683}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000684/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 684}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000685/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 685}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000686/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 686}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000687/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 687}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000688/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 688}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000689/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 689}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000690/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 690}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000691/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 691}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000692/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 692}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000693/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 693}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000694/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 694}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000695/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 695}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000696/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 696}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000697/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 697}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000698/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 698}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000699/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 699}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000700/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 700}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000701/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 701}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000702/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 702}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000703/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 703}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000704/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 704}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000705/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 705}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000706/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 706}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000707/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 707}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000708/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 708}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000709/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 709}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000710/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 710}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000711/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 711}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000712/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 712}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000713/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 713}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000714/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 714}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000715/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 715}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000716/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 716}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000717/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 717}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000718/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 718}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000719/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 719}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000720/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 720}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000721/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 721}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000722/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 722}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000723/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 723}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000724/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 724}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000725/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 725}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000726/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 726}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000727/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 727}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000728/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 728}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000729/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 729}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000730/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 730}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000731/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 731}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000732/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 732}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000733/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 733}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000734/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 734}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000735/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 735}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000736/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 736}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000737/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 737}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000738/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 738}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000739/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 739}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000740/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 740}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000741/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 741}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000742/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 742}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000743/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 743}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000744/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 744}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000745/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 745}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000746/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 746}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000747/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 747}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000748/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 748}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000749/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 749}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000750/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 750}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000751/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 751}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000752/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 752}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000753/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 753}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000754/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 754}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000755/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 755}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000756/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 756}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000757/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 757}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000758/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 758}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000759/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 759}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000760/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 760}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000761/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 761}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000762/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 762}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000763/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 763}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000764/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 764}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000765/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 765}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000766/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 766}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000767/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 767}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000768/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 768}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000769/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 769}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000770/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 770}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000771/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 771}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000772/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 772}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000773/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 773}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000774/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 774}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000775/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 775}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000776/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 776}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000777/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 777}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000778/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 778}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000779/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 779}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000780/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 780}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000781/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 781}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000782/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 782}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000783/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 783}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000784/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 784}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000785/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 785}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000786/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 786}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000787/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 787}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000788/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 788}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000789/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 789}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000790/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 790}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000791/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 791}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000792/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 792}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000793/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 793}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000794/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 794}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000795/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 795}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000796/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 796}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000797/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 797}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000798/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 798}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000799/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 799}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000800/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 800}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000801/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 801}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000802/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 802}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000803/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 803}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000804/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 804}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000805/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 805}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000806/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 806}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000807/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 807}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000808/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 808}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000809/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 809}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000810/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 810}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000811/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 811}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000812/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 812}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000813/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 813}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000814/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 814}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000815/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 815}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000816/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 816}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000817/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 817}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000818/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 818}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000819/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 819}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000820/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 820}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000821/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 821}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000822/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 822}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000823/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 823}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000824/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 824}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000825/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 825}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000826/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 826}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000827/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 827}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000828/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 828}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000829/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 829}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000830/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 830}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000831/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 831}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000832/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 832}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000833/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 833}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000834/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 834}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000835/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 835}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000836/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 836}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000837/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 837}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000838/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 838}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000839/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 839}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000840/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 840}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000841/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 841}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000842/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 842}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000843/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 843}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000844/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 844}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000845/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 845}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000846/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 846}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000847/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 847}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000848/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 848}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000849/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 849}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000850/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 850}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000851/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 851}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000852/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 852}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000853/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 853}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000854/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 854}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000855/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 855}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000856/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 856}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000857/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 857}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000858/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 858}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000859/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 859}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000860/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 860}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000861/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 861}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000862/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 862}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000863/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 863}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000864/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 864}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000865/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 865}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000866/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 866}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000867/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 867}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000868/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 868}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000869/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 869}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000870/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 870}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000871/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 871}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000872/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 872}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000873/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 873}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000874/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 874}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000875/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 875}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000876/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 876}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000877/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 877}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000878/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 878}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000879/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 879}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000880/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 880}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000881/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 881}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000882/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 882}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000883/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 883}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000884/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 884}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000885/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 885}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000886/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 886}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000887/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 887}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000888/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 888}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000889/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 889}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000890/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 890}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000891/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 891}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000892/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 892}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000893/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 893}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000894/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 894}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000895/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 895}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000896/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 896}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000897/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 897}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000898/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 898}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000899/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 899}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000900/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 900}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000901/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 901}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000902/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 902}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000903/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 903}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000904/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 904}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000905/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 905}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000906/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 906}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000907/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 907}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000908/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 908}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000909/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 909}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000910/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 910}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000911/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 911}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000912/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 912}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000913/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 913}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000914/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 914}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000915/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 915}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000916/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 916}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000917/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 917}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000918/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 918}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000919/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 919}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000920/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 920}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000921/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 921}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000922/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 922}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000923/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 923}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000924/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 924}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000925/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 925}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000926/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 926}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000927/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 927}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000928/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 928}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000929/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 929}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000930/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 930}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000931/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 931}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000932/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 932}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000933/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 933}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000934/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 934}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000935/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 935}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000936/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 936}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000937/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 937}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000938/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 938}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000939/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 939}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000940/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 940}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000941/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 941}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000942/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 942}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000943/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 943}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000944/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 944}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000945/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 945}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000946/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 946}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000947/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 947}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000948/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 948}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000949/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 949}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000950/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 950}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000951/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 951}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000952/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 952}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000953/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 953}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000954/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 954}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000955/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 955}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000956/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 956}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000957/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 957}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000958/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 958}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000959/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 959}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000960/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 960}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000961/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 961}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000962/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 962}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000963/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 963}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000964/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 964}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000965/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 965}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000966/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 966}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000967/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 967}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000968/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 968}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000969/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 969}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000970/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 970}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000971/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 971}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000972/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 972}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000973/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 973}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000974/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 974}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000975/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 975}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000976/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 976}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000977/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 977}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000978/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 978}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000979/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 979}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000980/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 980}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000981/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 981}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000982/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 982}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000983/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 983}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000984/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 984}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000985/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 985}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000986/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 986}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000987/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 987}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000988/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 988}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000989/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 989}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000990/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 990}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000991/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 991}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000992/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 992}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000993/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 993}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000994/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 994}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000995/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 995}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000996/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 996}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000997/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 997}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000998/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 998}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000999/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 999}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001000/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1000}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001001/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1001}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001002/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1002}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001003/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1003}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001004/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1004}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001005/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1005}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001006/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1006}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001007/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1007}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001008/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1008}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001009/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1009}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001010/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1010}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001011/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1011}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001012/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1012}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001013/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1013}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001014/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1014}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001015/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1015}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001016/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1016}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001017/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1017}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001018/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1018}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001019/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1019}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001020/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1020}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001021/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1021}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001022/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1022}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001023/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1023}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001024/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1024}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001025/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1025}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001026/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1026}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001027/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1027}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001028/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1028}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001029/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1029}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001030/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1030}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001031/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1031}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001032/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1032}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001033/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1033}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001034/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1034}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001035/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1035}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001036/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1036}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001037/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1037}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001038/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1038}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001039/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1039}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001040/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1040}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001041/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1041}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001042/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1042}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001043/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1043}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001044/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1044}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001045/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1045}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001046/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1046}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001047/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1047}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001048/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1048}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001049/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1049}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001050/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1050}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001051/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1051}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001052/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1052}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001053/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1053}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001054/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1054}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001055/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1055}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001056/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1056}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001057/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1057}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001058/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1058}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001059/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1059}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001060/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1060}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001061/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1061}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001062/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1062}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001063/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1063}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001064/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1064}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001065/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1065}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001066/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1066}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001067/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1067}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001068/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1068}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001069/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1069}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001070/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1070}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001071/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1071}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001072/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1072}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001073/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1073}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001074/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1074}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001075/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1075}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001076/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1076}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001077/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1077}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001078/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1078}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001079/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1079}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001080/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1080}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001081/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1081}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001082/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1082}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001083/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1083}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001084/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1084}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001085/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1085}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001086/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1086}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001087/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1087}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001088/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1088}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001089/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1089}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001090/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1090}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001091/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1091}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001092/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1092}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001093/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1093}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001094/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1094}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001095/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1095}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001096/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1096}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001097/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1097}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001098/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1098}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001099/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1099}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001100/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1100}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001101/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1101}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001102/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1102}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001103/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1103}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001104/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1104}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001105/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1105}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001106/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1106}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001107/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1107}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001108/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1108}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001109/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1109}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001110/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1110}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001111/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1111}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001112/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1112}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001113/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1113}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001114/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1114}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001115/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1115}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001116/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1116}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001117/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1117}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001118/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1118}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001119/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1119}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001120/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1120}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001121/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1121}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001122/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1122}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001123/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1123}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001124/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1124}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001125/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1125}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001126/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1126}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001127/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1127}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001128/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1128}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001129/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1129}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001130/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1130}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001131/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1131}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001132/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1132}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001133/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1133}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001134/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1134}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001135/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1135}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001136/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1136}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001137/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1137}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001138/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1138}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001139/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1139}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001140/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1140}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001141/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1141}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001142/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1142}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001143/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1143}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001144/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1144}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001145/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1145}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001146/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1146}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001147/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1147}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001148/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1148}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001149/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1149}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001150/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1150}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001151/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1151}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001152/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1152}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001153/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1153}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001154/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1154}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001155/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1155}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001156/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1156}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001157/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1157}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001158/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1158}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001159/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1159}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001160/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1160}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001161/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1161}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001162/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1162}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001163/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1163}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001164/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1164}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001165/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1165}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001166/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1166}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001167/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1167}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001168/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1168}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001169/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1169}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001170/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1170}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001171/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1171}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001172/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1172}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001173/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1173}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001174/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1174}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001175/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1175}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001176/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1176}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001177/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1177}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001178/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1178}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001179/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1179}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001180/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1180}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001181/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1181}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001182/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1182}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001183/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1183}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001184/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1184}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001185/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1185}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001186/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1186}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001187/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1187}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001188/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1188}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001189/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1189}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001190/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1190}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001191/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1191}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001192/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1192}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001193/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1193}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001194/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1194}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001195/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1195}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001196/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1196}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001197/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1197}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001198/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1198}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001199/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1199}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001200/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1200}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001201/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1201}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001202/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1202}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001203/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1203}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001204/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1204}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001205/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1205}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001206/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1206}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001207/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1207}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001208/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1208}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001209/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1209}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001210/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1210}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001211/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1211}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001212/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1212}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001213/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1213}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001214/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1214}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001215/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1215}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001216/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1216}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001217/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1217}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001218/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1218}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001219/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1219}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001220/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1220}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001221/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1221}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001222/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1222}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001223/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1223}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001224/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1224}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001225/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1225}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001226/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1226}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001227/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1227}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001228/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1228}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001229/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1229}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001230/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1230}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001231/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1231}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001232/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1232}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001233/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1233}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001234/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1234}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001235/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1235}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001236/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1236}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001237/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1237}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001238/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1238}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001239/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1239}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001240/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1240}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001241/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1241}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001242/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1242}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001243/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1243}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001244/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1244}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001245/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1245}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001246/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1246}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001247/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1247}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001248/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1248}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001249/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1249}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001250/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1250}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001251/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1251}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001252/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1252}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001253/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1253}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001254/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1254}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001255/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1255}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001256/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1256}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001257/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1257}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001258/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1258}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001259/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1259}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001260/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1260}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001261/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1261}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001262/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1262}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001263/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1263}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001264/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1264}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001265/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1265}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001266/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1266}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001267/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1267}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001268/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1268}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001269/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1269}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001270/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1270}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001271/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1271}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001272/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1272}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001273/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1273}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001274/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1274}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001275/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1275}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001276/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1276}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001277/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1277}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001278/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1278}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001279/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1279}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001280/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1280}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001281/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1281}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001282/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1282}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001283/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1283}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001284/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1284}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001285/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1285}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001286/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1286}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001287/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1287}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001288/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1288}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001289/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1289}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001290/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1290}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001291/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1291}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001292/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1292}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001293/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1293}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001294/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1294}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001295/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1295}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001296/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1296}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001297/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1297}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001298/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1298}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001299/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1299}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001300/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1300}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001301/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1301}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001302/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1302}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001303/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1303}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001304/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1304}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001305/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1305}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001306/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1306}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001307/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1307}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001308/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1308}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001309/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1309}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001310/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1310}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001311/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1311}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001312/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1312}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001313/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1313}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001314/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1314}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001315/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1315}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001316/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1316}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001317/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1317}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001318/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1318}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001319/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1319}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001320/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1320}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001321/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1321}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001322/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1322}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001323/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1323}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001324/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1324}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001325/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1325}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001326/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1326}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001327/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1327}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001328/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1328}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001329/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1329}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001330/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1330}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001331/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1331}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001332/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1332}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001333/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1333}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001334/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1334}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001335/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1335}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001336/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1336}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001337/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1337}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001338/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1338}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001339/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1339}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001340/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1340}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001341/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1341}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001342/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1342}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001343/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1343}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001344/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1344}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001345/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1345}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001346/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1346}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001347/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1347}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001348/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1348}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001349/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1349}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001350/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1350}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001351/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1351}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001352/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1352}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001353/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1353}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001354/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1354}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001355/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1355}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001356/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1356}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001357/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1357}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001358/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1358}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001359/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1359}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001360/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1360}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001361/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1361}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001362/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1362}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001363/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1363}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001364/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1364}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001365/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1365}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001366/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1366}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001367/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1367}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001368/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1368}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001369/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1369}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001370/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1370}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001371/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1371}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001372/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1372}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001373/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1373}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001374/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1374}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001375/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1375}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001376/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1376}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001377/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1377}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001378/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1378}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001379/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1379}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001380/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1380}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001381/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1381}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001382/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1382}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001383/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1383}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001384/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1384}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001385/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1385}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001386/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1386}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001387/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1387}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001388/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1388}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001389/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1389}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001390/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1390}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001391/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1391}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001392/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1392}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001393/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1393}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001394/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1394}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001395/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1395}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001396/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1396}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001397/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1397}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001398/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1398}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001399/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1399}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001400/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1400}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001401/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1401}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001402/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1402}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001403/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1403}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001404/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1404}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001405/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1405}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001406/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1406}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001407/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1407}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001408/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1408}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001409/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1409}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001410/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1410}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001411/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1411}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001412/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1412}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001413/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1413}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001414/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1414}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001415/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1415}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001416/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1416}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001417/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1417}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001418/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1418}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001419/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1419}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001420/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1420}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001421/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1421}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001422/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1422}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001423/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1423}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001424/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1424}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001425/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1425}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001426/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1426}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001427/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1427}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001428/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1428}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001429/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1429}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001430/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1430}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001431/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1431}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001432/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1432}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001433/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1433}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001434/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1434}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001435/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1435}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001436/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1436}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001437/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1437}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001438/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1438}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001439/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1439}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001440/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1440}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001441/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1441}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001442/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1442}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001443/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1443}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001444/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1444}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001445/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1445}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001446/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1446}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001447/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1447}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001448/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1448}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001449/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1449}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001450/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1450}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001451/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1451}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001452/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1452}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001453/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1453}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001454/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1454}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001455/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1455}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001456/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1456}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001457/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1457}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001458/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1458}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001459/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1459}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001460/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1460}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001461/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1461}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001462/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1462}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001463/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1463}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001464/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1464}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001465/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1465}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001466/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1466}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001467/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1467}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001468/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1468}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001469/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1469}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001470/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1470}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001471/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1471}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001472/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1472}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001473/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1473}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001474/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1474}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001475/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1475}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001476/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1476}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001477/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1477}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001478/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1478}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001479/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1479}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001480/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1480}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001481/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1481}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001482/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1482}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001483/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1483}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001484/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1484}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001485/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1485}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001486/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1486}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001487/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1487}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001488/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1488}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001489/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1489}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001490/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1490}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001491/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1491}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001492/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1492}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001493/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1493}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001494/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1494}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001495/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1495}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001496/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1496}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001497/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1497}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001498/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1498}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001499/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1499}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001500/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1500}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001501/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1501}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001502/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1502}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001503/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1503}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001504/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1504}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001505/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1505}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001506/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1506}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001507/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1507}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001508/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1508}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001509/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1509}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001510/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1510}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001511/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1511}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001512/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1512}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001513/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1513}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001514/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1514}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001515/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1515}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001516/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1516}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001517/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1517}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001518/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1518}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001519/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1519}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001520/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1520}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001521/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1521}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001522/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1522}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001523/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1523}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001524/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1524}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001525/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1525}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001526/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1526}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001527/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1527}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001528/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1528}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001529/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1529}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001530/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1530}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001531/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1531}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001532/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1532}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001533/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1533}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001534/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1534}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001535/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1535}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001536/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1536}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001537/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1537}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001538/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1538}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001539/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1539}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001540/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1540}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001541/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1541}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001542/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1542}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001543/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1543}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001544/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1544}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001545/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1545}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001546/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1546}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001547/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1547}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001548/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1548}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001549/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1549}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001550/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1550}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001551/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1551}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001552/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1552}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001553/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1553}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001554/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1554}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001555/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1555}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001556/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1556}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001557/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1557}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001558/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1558}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001559/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1559}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001560/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1560}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001561/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1561}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001562/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1562}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001563/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1563}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001564/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1564}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001565/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1565}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001566/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1566}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001567/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1567}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001568/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1568}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001569/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1569}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001570/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1570}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001571/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1571}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001572/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1572}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001573/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1573}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001574/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1574}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001575/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1575}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001576/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1576}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001577/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1577}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001578/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1578}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001579/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1579}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001580/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1580}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001581/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1581}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001582/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1582}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001583/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1583}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001584/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1584}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001585/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1585}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001586/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1586}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001587/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1587}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001588/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1588}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001589/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1589}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001590/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1590}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001591/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1591}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001592/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1592}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001593/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1593}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001594/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1594}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001595/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1595}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001596/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1596}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001597/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1597}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001598/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1598}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001599/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1599}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001600/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1600}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001601/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1601}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001602/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1602}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001603/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1603}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001604/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1604}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001605/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1605}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001606/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1606}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001607/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1607}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001608/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1608}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001609/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1609}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001610/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1610}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001611/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1611}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001612/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1612}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001613/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1613}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001614/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1614}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001615/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1615}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001616/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1616}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001617/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1617}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001618/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1618}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001619/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1619}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001620/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1620}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001621/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1621}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001622/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1622}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001623/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1623}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001624/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1624}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001625/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1625}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001626/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1626}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001627/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1627}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001628/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1628}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001629/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1629}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001630/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1630}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001631/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1631}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001632/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1632}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001633/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1633}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001634/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1634}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001635/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1635}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001636/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1636}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001637/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1637}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001638/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1638}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001639/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1639}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001640/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1640}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001641/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1641}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001642/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1642}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001643/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1643}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001644/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1644}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001645/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1645}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001646/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1646}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001647/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1647}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001648/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1648}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001649/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1649}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001650/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1650}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001651/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1651}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001652/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1652}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001653/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1653}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001654/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1654}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001655/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1655}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001656/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1656}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001657/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1657}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001658/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1658}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001659/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1659}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001660/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1660}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001661/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1661}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001662/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1662}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001663/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1663}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001664/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1664}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001665/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1665}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001666/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1666}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001667/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1667}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001668/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1668}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001669/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1669}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001670/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1670}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001671/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1671}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001672/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1672}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001673/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1673}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001674/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1674}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001675/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1675}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001676/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1676}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001677/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1677}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001678/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1678}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001679/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1679}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001680/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1680}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001681/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1681}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001682/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1682}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001683/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1683}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001684/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1684}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001685/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1685}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001686/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1686}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001687/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1687}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001688/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1688}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001689/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1689}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001690/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1690}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001691/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1691}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001692/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1692}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001693/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1693}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001694/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1694}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001695/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1695}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001696/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1696}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001697/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1697}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001698/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1698}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001699/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1699}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001700/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1700}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001701/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1701}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001702/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1702}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001703/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1703}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001704/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1704}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001705/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1705}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001706/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1706}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001707/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1707}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001708/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1708}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001709/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1709}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001710/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1710}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001711/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1711}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001712/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1712}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001713/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1713}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001714/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1714}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001715/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1715}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001716/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1716}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001717/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1717}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001718/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1718}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001719/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1719}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001720/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1720}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001721/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1721}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001722/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1722}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001723/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1723}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001724/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1724}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001725/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1725}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001726/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1726}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001727/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1727}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001728/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1728}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001729/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1729}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001730/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1730}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001731/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1731}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001732/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1732}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001733/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1733}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001734/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1734}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001735/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1735}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001736/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1736}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001737/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1737}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001738/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1738}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001739/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1739}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001740/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1740}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001741/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1741}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001742/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1742}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001743/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1743}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001744/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1744}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001745/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1745}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001746/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1746}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001747/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1747}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001748/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1748}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001749/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1749}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001750/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1750}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001751/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1751}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001752/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1752}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001753/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1753}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001754/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1754}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001755/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1755}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001756/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1756}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001757/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1757}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001758/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1758}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001759/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1759}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001760/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1760}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001761/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1761}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001762/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1762}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001763/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1763}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001764/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1764}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001765/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1765}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001766/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1766}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001767/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1767}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001768/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1768}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001769/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1769}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001770/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1770}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001771/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1771}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001772/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1772}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001773/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1773}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001774/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1774}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001775/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1775}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001776/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1776}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001777/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1777}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001778/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1778}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001779/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1779}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001780/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1780}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001781/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1781}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001782/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1782}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001783/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1783}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001784/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1784}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001785/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1785}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001786/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1786}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001787/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1787}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001788/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1788}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001789/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1789}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001790/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1790}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001791/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1791}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001792/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1792}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001793/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1793}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001794/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1794}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001795/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1795}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001796/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1796}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001797/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1797}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001798/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1798}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001799/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1799}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001800/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1800}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001801/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1801}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001802/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1802}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001803/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1803}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001804/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1804}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001805/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1805}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001806/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1806}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001807/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1807}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001808/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1808}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001809/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1809}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001810/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1810}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001811/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1811}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001812/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1812}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001813/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1813}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001814/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1814}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001815/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1815}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001816/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1816}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001817/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1817}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001818/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1818}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001819/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1819}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001820/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1820}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001821/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1821}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001822/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1822}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001823/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1823}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001824/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1824}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001825/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1825}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001826/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1826}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001827/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1827}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001828/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1828}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001829/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1829}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001830/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1830}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001831/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1831}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001832/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1832}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001833/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1833}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001834/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1834}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001835/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1835}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001836/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1836}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001837/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1837}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001838/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1838}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001839/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1839}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001840/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1840}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001841/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1841}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001842/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1842}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001843/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1843}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001844/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1844}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001845/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1845}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001846/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1846}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001847/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1847}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001848/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1848}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001849/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1849}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001850/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1850}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001851/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1851}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001852/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1852}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001853/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1853}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001854/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1854}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001855/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1855}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001856/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1856}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001857/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1857}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001858/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1858}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001859/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1859}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001860/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1860}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001861/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1861}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001862/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1862}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001863/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1863}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001864/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1864}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001865/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1865}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001866/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1866}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001867/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1867}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001868/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1868}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001869/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1869}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001870/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1870}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001871/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1871}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001872/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1872}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001873/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1873}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001874/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1874}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001875/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1875}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001876/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1876}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001877/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1877}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001878/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1878}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001879/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1879}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001880/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1880}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001881/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1881}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001882/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1882}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001883/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1883}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001884/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1884}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001885/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1885}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001886/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1886}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001887/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1887}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001888/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1888}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001889/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1889}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001890/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1890}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001891/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1891}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001892/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1892}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001893/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1893}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001894/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1894}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001895/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1895}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001896/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1896}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001897/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1897}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001898/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1898}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001899/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1899}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001900/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1900}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001901/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1901}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001902/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1902}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001903/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1903}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001904/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1904}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001905/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1905}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001906/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1906}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001907/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1907}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001908/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1908}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001909/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1909}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001910/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1910}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001911/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, ��� — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1911}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001912/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1912}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001913/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1913}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001914/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1914}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001915/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1915}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001916/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1916}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001917/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1917}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001918/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1918}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001919/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1919}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001920/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1920}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001921/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1921}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001922/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1922}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001923/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1923}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001924/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1924}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001925/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1925}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001926/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1926}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001927/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1927}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001928/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1928}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001929/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1929}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001930/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1930}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001931/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1931}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001932/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1932}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001933/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1933}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001934/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1934}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001935/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1935}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001936/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1936}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001937/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1937}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001938/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1938}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001939/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1939}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001940/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1940}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001941/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1941}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001942/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1942}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001943/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1943}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001944/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1944}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001945/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1945}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001946/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1946}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001947/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1947}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001948/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1948}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001949/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1949}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001950/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1950}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001951/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1951}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001952/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1952}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001953/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1953}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001954/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1954}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001955/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1955}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001956/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1956}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001957/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1957}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001958/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1958}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001959/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1959}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001960/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1960}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001961/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1961}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001962/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1962}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001963/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1963}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001964/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1964}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001965/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1965}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001966/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1966}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001967/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1967}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001968/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1968}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001969/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1969}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001970/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1970}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001971/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1971}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001972/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1972}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001973/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1973}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001974/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1974}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001975/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1975}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001976/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1976}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001977/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1977}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001978/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1978}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001979/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1979}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001980/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1980}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001981/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1981}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001982/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1982}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001983/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1983}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001984/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1984}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001985/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1985}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001986/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1986}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001987/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1987}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001988/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1988}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001989/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1989}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001990/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1990}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001991/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1991}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001992/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1992}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001993/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1993}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001994/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1994}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001995/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1995}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001996/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1996}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001997/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1997}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001998/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1998}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001999/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1999}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002000/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2000}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002001/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2001}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002002/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2002}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002003/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2003}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002004/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2004}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002005/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2005}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002006/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2006}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002007/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2007}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002008/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2008}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002009/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2009}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002010/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2010}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002011/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2011}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002012/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2012}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002013/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2013}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002014/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2014}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002015/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2015}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002016/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2016}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002017/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2017}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002018/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2018}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002019/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2019}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002020/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2020}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002021/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2021}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002022/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2022}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002023/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2023}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002024/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2024}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002025/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2025}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002026/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2026}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002027/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2027}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002028/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2028}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002029/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2029}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002030/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2030}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002031/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2031}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002032/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2032}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002033/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2033}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002034/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2034}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002035/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2035}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002036/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2036}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002037/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2037}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002038/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2038}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002039/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2039}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002040/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2040}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002041/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2041}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002042/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2042}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002043/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2043}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002044/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2044}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002045/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2045}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002046/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2046}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002047/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2047}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002048/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2048}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002049/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2049}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002050/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2050}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002051/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2051}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002052/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2052}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002053/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2053}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002054/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2054}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002055/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2055}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002056/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2056}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002057/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2057}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002058/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2058}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002059/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2059}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002060/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2060}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002061/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2061}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002062/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2062}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002063/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2063}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002064/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2064}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002065/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2065}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002066/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2066}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002067/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2067}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002068/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2068}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002069/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2069}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002070/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2070}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002071/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2071}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002072/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2072}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002073/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2073}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002074/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2074}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002075/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2075}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002076/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2076}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002077/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2077}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002078/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2078}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002079/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2079}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002080/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2080}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002081/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2081}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002082/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2082}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002083/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2083}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002084/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2084}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002085/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2085}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002086/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2086}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002087/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2087}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002088/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2088}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002089/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2089}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002090/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2090}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002091/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2091}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002092/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2092}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002093/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2093}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002094/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2094}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002095/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2095}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002096/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2096}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002097/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2097}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002098/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2098}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002099/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2099}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002100/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2100}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002101/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2101}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002102/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2102}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002103/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2103}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002104/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2104}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002105/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2105}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002106/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2106}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002107/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2107}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002108/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2108}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002109/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2109}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002110/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2110}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002111/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2111}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002112/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2112}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002113/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2113}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002114/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2114}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002115/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2115}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002116/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2116}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002117/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2117}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002118/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2118}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002119/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2119}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002120/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2120}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002121/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2121}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002122/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2122}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002123/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2123}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002124/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2124}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002125/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2125}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002126/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2126}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002127/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2127}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002128/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2128}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002129/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2129}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002130/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2130}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002131/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2131}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002132/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2132}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002133/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2133}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002134/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2134}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002135/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2135}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002136/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2136}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002137/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2137}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002138/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2138}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002139/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2139}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002140/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2140}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002141/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2141}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002142/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2142}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002143/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2143}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002144/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2144}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002145/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2145}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002146/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2146}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002147/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2147}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002148/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2148}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002149/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2149}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002150/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2150}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002151/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2151}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002152/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2152}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002153/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2153}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002154/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2154}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002155/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2155}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002156/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2156}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002157/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2157}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002158/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2158}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002159/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2159}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002160/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2160}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002161/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2161}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002162/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2162}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002163/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2163}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002164/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2164}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002165/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2165}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002166/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2166}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002167/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2167}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002168/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2168}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002169/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2169}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002170/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2170}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002171/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2171}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002172/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2172}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002173/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2173}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002174/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2174}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002175/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2175}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002176/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2176}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002177/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2177}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002178/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2178}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002179/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2179}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002180/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2180}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002181/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2181}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002182/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2182}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002183/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2183}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002184/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2184}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002185/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2185}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002186/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2186}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002187/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2187}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002188/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2188}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002189/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2189}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002190/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2190}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002191/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2191}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002192/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2192}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002193/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2193}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002194/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2194}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002195/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2195}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002196/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2196}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002197/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2197}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002198/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2198}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002199/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2199}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002200/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2200}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002201/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2201}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002202/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2202}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002203/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2203}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002204/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2204}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002205/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2205}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002206/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2206}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002207/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2207}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002208/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2208}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002209/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2209}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002210/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2210}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002211/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2211}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002212/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2212}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002213/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2213}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002214/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2214}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002215/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2215}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002216/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2216}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002217/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2217}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002218/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2218}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002219/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2219}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002220/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2220}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002221/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2221}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002222/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2222}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002223/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2223}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002224/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2224}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002225/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2225}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002226/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2226}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002227/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2227}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002228/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2228}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002229/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2229}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002230/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2230}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002231/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2231}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002232/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2232}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002233/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2233}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002234/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2234}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002235/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2235}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002236/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2236}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002237/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2237}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002238/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2238}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002239/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2239}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002240/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2240}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002241/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2241}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002242/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2242}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002243/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2243}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002244/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2244}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002245/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2245}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002246/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2246}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002247/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2247}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002248/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2248}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002249/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2249}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002250/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2250}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002251/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2251}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002252/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2252}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002253/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2253}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002254/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2254}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002255/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2255}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002256/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2256}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002257/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2257}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002258/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2258}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002259/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2259}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002260/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2260}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002261/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2261}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002262/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2262}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002263/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2263}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002264/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2264}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002265/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2265}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002266/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2266}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002267/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2267}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002268/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2268}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002269/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2269}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002270/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2270}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002271/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2271}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002272/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2272}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002273/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2273}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002274/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2274}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002275/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2275}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002276/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2276}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002277/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2277}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002278/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2278}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002279/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2279}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002280/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2280}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002281/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2281}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002282/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2282}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002283/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2283}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002284/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2284}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002285/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2285}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002286/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2286}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002287/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2287}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002288/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2288}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002289/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2289}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002290/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2290}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002291/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2291}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002292/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2292}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002293/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2293}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002294/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2294}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002295/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2295}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002296/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2296}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002297/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2297}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002298/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2298}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002299/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2299}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002300/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2300}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002301/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2301}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002302/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2302}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002303/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2303}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002304/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2304}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002305/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2305}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002306/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2306}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002307/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2307}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002308/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2308}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002309/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2309}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002310/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2310}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002311/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2311}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002312/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2312}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002313/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2313}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002314/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2314}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002315/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2315}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002316/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2316}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002317/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2317}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002318/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2318}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002319/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2319}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002320/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2320}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002321/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2321}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002322/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2322}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002323/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2323}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002324/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2324}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002325/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2325}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002326/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2326}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002327/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2327}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002328/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2328}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002329/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2329}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002330/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2330}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002331/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2331}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002332/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2332}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002333/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2333}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002334/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2334}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002335/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2335}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002336/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2336}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002337/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2337}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002338/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2338}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002339/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2339}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002340/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2340}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002341/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2341}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002342/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2342}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002343/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2343}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002344/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2344}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002345/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2345}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002346/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2346}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002347/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2347}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002348/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2348}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002349/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2349}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002350/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2350}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002351/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2351}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002352/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2352}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002353/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2353}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002354/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2354}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002355/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2355}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002356/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2356}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002357/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2357}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002358/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2358}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002359/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2359}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002360/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2360}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002361/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2361}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002362/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2362}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002363/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2363}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002364/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2364}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002365/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2365}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002366/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2366}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002367/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2367}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002368/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2368}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002369/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2369}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002370/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2370}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002371/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2371}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002372/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2372}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002373/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2373}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002374/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2374}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002375/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2375}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002376/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2376}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002377/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2377}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002378/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2378}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002379/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2379}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002380/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2380}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002381/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2381}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002382/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2382}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002383/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2383}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002384/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2384}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002385/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2385}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002386/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2386}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002387/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2387}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002388/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2388}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002389/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2389}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002390/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2390}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002391/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2391}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002392/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2392}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002393/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2393}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002394/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2394}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002395/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2395}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002396/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2396}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002397/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2397}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002398/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2398}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002399/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2399}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002400/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2400}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002401/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2401}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002402/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2402}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002403/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2403}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002404/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2404}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002405/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2405}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002406/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2406}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002407/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2407}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002408/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2408}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002409/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2409}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002410/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2410}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002411/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2411}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002412/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2412}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002413/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2413}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002414/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2414}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002415/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2415}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002416/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2416}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002417/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2417}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002418/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2418}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002419/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2419}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002420/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2420}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002421/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2421}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002422/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2422}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002423/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2423}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002424/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2424}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002425/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2425}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002426/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2426}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002427/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2427}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002428/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2428}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002429/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2429}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002430/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2430}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002431/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2431}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002432/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2432}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002433/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2433}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002434/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2434}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002435/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2435}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002436/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2436}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002437/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2437}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002438/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2438}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002439/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2439}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002440/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2440}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002441/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2441}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002442/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2442}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002443/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2443}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002444/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2444}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002445/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2445}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002446/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2446}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002447/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2447}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002448/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2448}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002449/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2449}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002450/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2450}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002451/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2451}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002452/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2452}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002453/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2453}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002454/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2454}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002455/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2455}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002456/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2456}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002457/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2457}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002458/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2458}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002459/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2459}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002460/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2460}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002461/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2461}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002462/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2462}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002463/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2463}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002464/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2464}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002465/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2465}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002466/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2466}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002467/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2467}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002468/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2468}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002469/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2469}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002470/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2470}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002471/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2471}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002472/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2472}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002473/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2473}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002474/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2474}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002475/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2475}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002476/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2476}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002477/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2477}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002478/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2478}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002479/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2479}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002480/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2480}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002481/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2481}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002482/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2482}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002483/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2483}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002484/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2484}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002485/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2485}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002486/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2486}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002487/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2487}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002488/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2488}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002489/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2489}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002490/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2490}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002491/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2491}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002492/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2492}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002493/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2493}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002494/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2494}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002495/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2495}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002496/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2496}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002497/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2497}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002498/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2498}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002499/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2499}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002500/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2500}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002501/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2501}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002502/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2502}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002503/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2503}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002504/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2504}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002505/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2505}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002506/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2506}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002507/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2507}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002508/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2508}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002509/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2509}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002510/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2510}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002511/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2511}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002512/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2512}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002513/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2513}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002514/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2514}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002515/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2515}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002516/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2516}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002517/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2517}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002518/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2518}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002519/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2519}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002520/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2520}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002521/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2521}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002522/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2522}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002523/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2523}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002524/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2524}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002525/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2525}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002526/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2526}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002527/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2527}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002528/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2528}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002529/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2529}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002530/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2530}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002531/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2531}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002532/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2532}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002533/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2533}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002534/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2534}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002535/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2535}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002536/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2536}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002537/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2537}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002538/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2538}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002539/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2539}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002540/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2540}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002541/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2541}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002542/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2542}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002543/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2543}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002544/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2544}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002545/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2545}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002546/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2546}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002547/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2547}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002548/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2548}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002549/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2549}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002550/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2550}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002551/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2551}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002552/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2552}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002553/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2553}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002554/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2554}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002555/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2555}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002556/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2556}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002557/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2557}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002558/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2558}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002559/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2559}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002560/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2560}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002561/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2561}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002562/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2562}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002563/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2563}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002564/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2564}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002565/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2565}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002566/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2566}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002567/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2567}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002568/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2568}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002569/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2569}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002570/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2570}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002571/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2571}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002572/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2572}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002573/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2573}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002574/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2574}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002575/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2575}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002576/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2576}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002577/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2577}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002578/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2578}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002579/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2579}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002580/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2580}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002581/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2581}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002582/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2582}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002583/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2583}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002584/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2584}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002585/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2585}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002586/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2586}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002587/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2587}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002588/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2588}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002589/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2589}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002590/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2590}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002591/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2591}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002592/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2592}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002593/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2593}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002594/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2594}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002595/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2595}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002596/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2596}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002597/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2597}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002598/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2598}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002599/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2599}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002600/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2600}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002601/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2601}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002602/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2602}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002603/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2603}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002604/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2604}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002605/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2605}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002606/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2606}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002607/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2607}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002608/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2608}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002609/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2609}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002610/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2610}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002611/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2611}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002612/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2612}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002613/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2613}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002614/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2614}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002615/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2615}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002616/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2616}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002617/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2617}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002618/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2618}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002619/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2619}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002620/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2620}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002621/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2621}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002622/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2622}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002623/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2623}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002624/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2624}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002625/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2625}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002626/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2626}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002627/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2627}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002628/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2628}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002629/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2629}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002630/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2630}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002631/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2631}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002632/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2632}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002633/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2633}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002634/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2634}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002635/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2635}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002636/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2636}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002637/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2637}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002638/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2638}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002639/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2639}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002640/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2640}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002641/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2641}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002642/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2642}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002643/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2643}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002644/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2644}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002645/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2645}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002646/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2646}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002647/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2647}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002648/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2648}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002649/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2649}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002650/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2650}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002651/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2651}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002652/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2652}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002653/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2653}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002654/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2654}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002655/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2655}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002656/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2656}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002657/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2657}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002658/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2658}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002659/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2659}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002660/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2660}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002661/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2661}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002662/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2662}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002663/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2663}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002664/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2664}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002665/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2665}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002666/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2666}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002667/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2667}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002668/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2668}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002669/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2669}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002670/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2670}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002671/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2671}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002672/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2672}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002673/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2673}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002674/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2674}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002675/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2675}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002676/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2676}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002677/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2677}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002678/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2678}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002679/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2679}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002680/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2680}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002681/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2681}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002682/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2682}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002683/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2683}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002684/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2684}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002685/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2685}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002686/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2686}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002687/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2687}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002688/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2688}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002689/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2689}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002690/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2690}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002691/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2691}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002692/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2692}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002693/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2693}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002694/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2694}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002695/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2695}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002696/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2696}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002697/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2697}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002698/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2698}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002699/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2699}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002700/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2700}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002701/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2701}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002702/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2702}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002703/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2703}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002704/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2704}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002705/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2705}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002706/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2706}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002707/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2707}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002708/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2708}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002709/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2709}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002710/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2710}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002711/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2711}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002712/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2712}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002713/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2713}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002714/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2714}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002715/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2715}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002716/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2716}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002717/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2717}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002718/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2718}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002719/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2719}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002720/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2720}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002721/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2721}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002722/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2722}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002723/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2723}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002724/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2724}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002725/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2725}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002726/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2726}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002727/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2727}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002728/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2728}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002729/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2729}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002730/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2730}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002731/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2731}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002732/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2732}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002733/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2733}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002734/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2734}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002735/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2735}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002736/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2736}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002737/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2737}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002738/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2738}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002739/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2739}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002740/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2740}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002741/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2741}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002742/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2742}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002743/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2743}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002744/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2744}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002745/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2745}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002746/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2746}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002747/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2747}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002748/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2748}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002749/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2749}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002750/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2750}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002751/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2751}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002752/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2752}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002753/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2753}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002754/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2754}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002755/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2755}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002756/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2756}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002757/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2757}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002758/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2758}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002759/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2759}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002760/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2760}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002761/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2761}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002762/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2762}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002763/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2763}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002764/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2764}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002765/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2765}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002766/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2766}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002767/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2767}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002768/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2768}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002769/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2769}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002770/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2770}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002771/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2771}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002772/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2772}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002773/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2773}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002774/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2774}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002775/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2775}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002776/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2776}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002777/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2777}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002778/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2778}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002779/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2779}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002780/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2780}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002781/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2781}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002782/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2782}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002783/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2783}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002784/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2784}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002785/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2785}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002786/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2786}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002787/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2787}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002788/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2788}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002789/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2789}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002790/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2790}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002791/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2791}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002792/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2792}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002793/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2793}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002794/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2794}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002795/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2795}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002796/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2796}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002797/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2797}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002798/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2798}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002799/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2799}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002800/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2800}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002801/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2801}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002802/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2802}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002803/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2803}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002804/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2804}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002805/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2805}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002806/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2806}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002807/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2807}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002808/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2808}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002809/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2809}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002810/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2810}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002811/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2811}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002812/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2812}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002813/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2813}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002814/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2814}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002815/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2815}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002816/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2816}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002817/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2817}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002818/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2818}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002819/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2819}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002820/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2820}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002821/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2821}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002822/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2822}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002823/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2823}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002824/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2824}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002825/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2825}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002826/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2826}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002827/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2827}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002828/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2828}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002829/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2829}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002830/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2830}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002831/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2831}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002832/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2832}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002833/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2833}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002834/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2834}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002835/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2835}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002836/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2836}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002837/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2837}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002838/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2838}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002839/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2839}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002840/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2840}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002841/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2841}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002842/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2842}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002843/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2843}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002844/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2844}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002845/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2845}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002846/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2846}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002847/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2847}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002848/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2848}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002849/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2849}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002850/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2850}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002851/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2851}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002852/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2852}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002853/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2853}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002854/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2854}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002855/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2855}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002856/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2856}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002857/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2857}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002858/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2858}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002859/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2859}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002860/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2860}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002861/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2861}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002862/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2862}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002863/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2863}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002864/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2864}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002865/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2865}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002866/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2866}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002867/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2867}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002868/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2868}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002869/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2869}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002870/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2870}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002871/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2871}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002872/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2872}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002873/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2873}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002874/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2874}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002875/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2875}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002876/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2876}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002877/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2877}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002878/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2878}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002879/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2879}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002880/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2880}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002881/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2881}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002882/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2882}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002883/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2883}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002884/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2884}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002885/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2885}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002886/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2886}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002887/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2887}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002888/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2888}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002889/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2889}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002890/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2890}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002891/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2891}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002892/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2892}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002893/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2893}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002894/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2894}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002895/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2895}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002896/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2896}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002897/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2897}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002898/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2898}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002899/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2899}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002900/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2900}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002901/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2901}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002902/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2902}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002903/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2903}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002904/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2904}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002905/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2905}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002906/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2906}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002907/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2907}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002908/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2908}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002909/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2909}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002910/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2910}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002911/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2911}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002912/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2912}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002913/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2913}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002914/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2914}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002915/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2915}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002916/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2916}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002917/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2917}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002918/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2918}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002919/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2919}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002920/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2920}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002921/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2921}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002922/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2922}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002923/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2923}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002924/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2924}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002925/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2925}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002926/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2926}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002927/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2927}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002928/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2928}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002929/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2929}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002930/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2930}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002931/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2931}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002932/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2932}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002933/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2933}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002934/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2934}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002935/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2935}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002936/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2936}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002937/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2937}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002938/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2938}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002939/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2939}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002940/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2940}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002941/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2941}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002942/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2942}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002943/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2943}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002944/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2944}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002945/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2945}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002946/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2946}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002947/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2947}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002948/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2948}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002949/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2949}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002950/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2950}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002951/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2951}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002952/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2952}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002953/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2953}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002954/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2954}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002955/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2955}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002956/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2956}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002957/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2957}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002958/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2958}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002959/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2959}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002960/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2960}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002961/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2961}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002962/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2962}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002963/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2963}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002964/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2964}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002965/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2965}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002966/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2966}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002967/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2967}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002968/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2968}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002969/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2969}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002970/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2970}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002971/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2971}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002972/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2972}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002973/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2973}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002974/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2974}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002975/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2975}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002976/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2976}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002977/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2977}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002978/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2978}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002979/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2979}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002980/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2980}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002981/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2981}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002982/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2982}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002983/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2983}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002984/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2984}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002985/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2985}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002986/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2986}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002987/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2987}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002988/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2988}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002989/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2989}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002990/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2990}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002991/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2991}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002992/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2992}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002993/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2993}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002994/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2994}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002995/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2995}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002996/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2996}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002997/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2997}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002998/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2998}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002999/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2999}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003000/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3000}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003001/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3001}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003002/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3002}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003003/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3003}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003004/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3004}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003005/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3005}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003006/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3006}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003007/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3007}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003008/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3008}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003009/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3009}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003010/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3010}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003011/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3011}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003012/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3012}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003013/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3013}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003014/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3014}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003015/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3015}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003016/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3016}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003017/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3017}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003018/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3018}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003019/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3019}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003020/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3020}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003021/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3021}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003022/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3022}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003023/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3023}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003024/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3024}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003025/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3025}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003026/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3026}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003027/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3027}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003028/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3028}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003029/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3029}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003030/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3030}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003031/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3031}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003032/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3032}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003033/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3033}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003034/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3034}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003035/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3035}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003036/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3036}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003037/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3037}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003038/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3038}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003039/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3039}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003040/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3040}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003041/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3041}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003042/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3042}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003043/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3043}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003044/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3044}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003045/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3045}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003046/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3046}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003047/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3047}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003048/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3048}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003049/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3049}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003050/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3050}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003051/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3051}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003052/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3052}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003053/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3053}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003054/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3054}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003055/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3055}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003056/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3056}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003057/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3057}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003058/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3058}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003059/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3059}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003060/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3060}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003061/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3061}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003062/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3062}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003063/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3063}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003064/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3064}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003065/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3065}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003066/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3066}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003067/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3067}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003068/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3068}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003069/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3069}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003070/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3070}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003071/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3071}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003072/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3072}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003073/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3073}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003074/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3074}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003075/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3075}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003076/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3076}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003077/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3077}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003078/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3078}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003079/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3079}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003080/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3080}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003081/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3081}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003082/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3082}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003083/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3083}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003084/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3084}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003085/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3085}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003086/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3086}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003087/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3087}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003088/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3088}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003089/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3089}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003090/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3090}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003091/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3091}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003092/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3092}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003093/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3093}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003094/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3094}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003095/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3095}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003096/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3096}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003097/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3097}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003098/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3098}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003099/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3099}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003100/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3100}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003101/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3101}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003102/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3102}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003103/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3103}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003104/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3104}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003105/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3105}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003106/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3106}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003107/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3107}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003108/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3108}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003109/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3109}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003110/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3110}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003111/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3111}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003112/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3112}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003113/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3113}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003114/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3114}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003115/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3115}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003116/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3116}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003117/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3117}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003118/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3118}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003119/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3119}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003120/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3120}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003121/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3121}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003122/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3122}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003123/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3123}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003124/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3124}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003125/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3125}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003126/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3126}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003127/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3127}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003128/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3128}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003129/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3129}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003130/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3130}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003131/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3131}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003132/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3132}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003133/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3133}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003134/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3134}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003135/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3135}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003136/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3136}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003137/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3137}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003138/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3138}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003139/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3139}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003140/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3140}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003141/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3141}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003142/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3142}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003143/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3143}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003144/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3144}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003145/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3145}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003146/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3146}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003147/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3147}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003148/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3148}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003149/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3149}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003150/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3150}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003151/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3151}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003152/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3152}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003153/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3153}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003154/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3154}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003155/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3155}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003156/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3156}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003157/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3157}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003158/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3158}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003159/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3159}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003160/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3160}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003161/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3161}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003162/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3162}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003163/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3163}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003164/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3164}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003165/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3165}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003166/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3166}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003167/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3167}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003168/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3168}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003169/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3169}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003170/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3170}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003171/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3171}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003172/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3172}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003173/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3173}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003174/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3174}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003175/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3175}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003176/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3176}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003177/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3177}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003178/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3178}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003179/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3179}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003180/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3180}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003181/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3181}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003182/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3182}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003183/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3183}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003184/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3184}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003185/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3185}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003186/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3186}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003187/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3187}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003188/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3188}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003189/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3189}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003190/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3190}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003191/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3191}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003192/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3192}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003193/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3193}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003194/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3194}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003195/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3195}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003196/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3196}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003197/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3197}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003198/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3198}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003199/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3199}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003200/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3200}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003201/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3201}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003202/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3202}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003203/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3203}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003204/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3204}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003205/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3205}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003206/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3206}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003207/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3207}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003208/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3208}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003209/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3209}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003210/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3210}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003211/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3211}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003212/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3212}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003213/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3213}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003214/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3214}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003215/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3215}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003216/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3216}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003217/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3217}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003218/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3218}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003219/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3219}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003220/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3220}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003221/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3221}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003222/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3222}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003223/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3223}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003224/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3224}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003225/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3225}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003226/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3226}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003227/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3227}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003228/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3228}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003229/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3229}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003230/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3230}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003231/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3231}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003232/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3232}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003233/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3233}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003234/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3234}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003235/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3235}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003236/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3236}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003237/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3237}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003238/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3238}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003239/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3239}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003240/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3240}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003241/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3241}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003242/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3242}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003243/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3243}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003244/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3244}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003245/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3245}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003246/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3246}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003247/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3247}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003248/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3248}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003249/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3249}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003250/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3250}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003251/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3251}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003252/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3252}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003253/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3253}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003254/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3254}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003255/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3255}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003256/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3256}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003257/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3257}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003258/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3258}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003259/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3259}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003260/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3260}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003261/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3261}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003262/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3262}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003263/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3263}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003264/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3264}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003265/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3265}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003266/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3266}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003267/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3267}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003268/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3268}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003269/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3269}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003270/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3270}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003271/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3271}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003272/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3272}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003273/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3273}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003274/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3274}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003275/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3275}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003276/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3276}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003277/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3277}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003278/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3278}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003279/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3279}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003280/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3280}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003281/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3281}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003282/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3282}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003283/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3283}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003284/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3284}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003285/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3285}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003286/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3286}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003287/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3287}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003288/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3288}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003289/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3289}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003290/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3290}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003291/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3291}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003292/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3292}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003293/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3293}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003294/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3294}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003295/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3295}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003296/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3296}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003297/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3297}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003298/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3298}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003299/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3299}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003300/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3300}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003301/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3301}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003302/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3302}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003303/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3303}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003304/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3304}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003305/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3305}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003306/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3306}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003307/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3307}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003308/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3308}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003309/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3309}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003310/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3310}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003311/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3311}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003312/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3312}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003313/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3313}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003314/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3314}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003315/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3315}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003316/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3316}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003317/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3317}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003318/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3318}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003319/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3319}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003320/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3320}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003321/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3321}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003322/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3322}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003323/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3323}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003324/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3324}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003325/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3325}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003326/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3326}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003327/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3327}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003328/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3328}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003329/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3329}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003330/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3330}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003331/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3331}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003332/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3332}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003333/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3333}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003334/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3334}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003335/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3335}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003336/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3336}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003337/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3337}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003338/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3338}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003339/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3339}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003340/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3340}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003341/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3341}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003342/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3342}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003343/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3343}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003344/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3344}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003345/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3345}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003346/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3346}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003347/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3347}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003348/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3348}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003349/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3349}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003350/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3350}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003351/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3351}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003352/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3352}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003353/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3353}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003354/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3354}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003355/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3355}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003356/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3356}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003357/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3357}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003358/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3358}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003359/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3359}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003360/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3360}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003361/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3361}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003362/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3362}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003363/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3363}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003364/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3364}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003365/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3365}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003366/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3366}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003367/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3367}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003368/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3368}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003369/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3369}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003370/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3370}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003371/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3371}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003372/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3372}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003373/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3373}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003374/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3374}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003375/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3375}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003376/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3376}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003377/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3377}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003378/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3378}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003379/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3379}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003380/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3380}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003381/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3381}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003382/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3382}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003383/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3383}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003384/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3384}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003385/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3385}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003386/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3386}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003387/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3387}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003388/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3388}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003389/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3389}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003390/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3390}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003391/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3391}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003392/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3392}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003393/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3393}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003394/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3394}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003395/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3395}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003396/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3396}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003397/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3397}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003398/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3398}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003399/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3399}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003400/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3400}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003401/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3401}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003402/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3402}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003403/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3403}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003404/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3404}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003405/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3405}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003406/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3406}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003407/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3407}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003408/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3408}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003409/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3409}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003410/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3410}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003411/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3411}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003412/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3412}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003413/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3413}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003414/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3414}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003415/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3415}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003416/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3416}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003417/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3417}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003418/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3418}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003419/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3419}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003420/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3420}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003421/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3421}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003422/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3422}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003423/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3423}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003424/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3424}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003425/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3425}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003426/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3426}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003427/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3427}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003428/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3428}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003429/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3429}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003430/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3430}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003431/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3431}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003432/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3432}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003433/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3433}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003434/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3434}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003435/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3435}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003436/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3436}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003437/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3437}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003438/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3438}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003439/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3439}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003440/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3440}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003441/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3441}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003442/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3442}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003443/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3443}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003444/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3444}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003445/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3445}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003446/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3446}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003447/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3447}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003448/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3448}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003449/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3449}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003450/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3450}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003451/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3451}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003452/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3452}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003453/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3453}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003454/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3454}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003455/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3455}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003456/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3456}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003457/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3457}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003458/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3458}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003459/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3459}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003460/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3460}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003461/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3461}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003462/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3462}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003463/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3463}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003464/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3464}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003465/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3465}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003466/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3466}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003467/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3467}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003468/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3468}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003469/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3469}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003470/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3470}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003471/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3471}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003472/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3472}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003473/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3473}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003474/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3474}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003475/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3475}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003476/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3476}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003477/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3477}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003478/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3478}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003479/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3479}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003480/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3480}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003481/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3481}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003482/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3482}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003483/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3483}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003484/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3484}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003485/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3485}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003486/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3486}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003487/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3487}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003488/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3488}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003489/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3489}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003490/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3490}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003491/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3491}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003492/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3492}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003493/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3493}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003494/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3494}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003495/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3495}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003496/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3496}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003497/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3497}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003498/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3498}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003499/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3499}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003500/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3500}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003501/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3501}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003502/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3502}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003503/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3503}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003504/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3504}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003505/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3505}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003506/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3506}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003507/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3507}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003508/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3508}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003509/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3509}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003510/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3510}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003511/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3511}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003512/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3512}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003513/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3513}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003514/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3514}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003515/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3515}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003516/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3516}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003517/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3517}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003518/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3518}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003519/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3519}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003520/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3520}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003521/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3521}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003522/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3522}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003523/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3523}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003524/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3524}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003525/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3525}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003526/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3526}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003527/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3527}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003528/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3528}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003529/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3529}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003530/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3530}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003531/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3531}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003532/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3532}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003533/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3533}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003534/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3534}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003535/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3535}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003536/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3536}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003537/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3537}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003538/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3538}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003539/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3539}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003540/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3540}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003541/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3541}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003542/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3542}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003543/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3543}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003544/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3544}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003545/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3545}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003546/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3546}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003547/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3547}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003548/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3548}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003549/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3549}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003550/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3550}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003551/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3551}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003552/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3552}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003553/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3553}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003554/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3554}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003555/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3555}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003556/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3556}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003557/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3557}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003558/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3558}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003559/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3559}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003560/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3560}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003561/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3561}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003562/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3562}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003563/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3563}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003564/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3564}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003565/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3565}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003566/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3566}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003567/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3567}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003568/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3568}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003569/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3569}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003570/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3570}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003571/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3571}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003572/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3572}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003573/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3573}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003574/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3574}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003575/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3575}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003576/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3576}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003577/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3577}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003578/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3578}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003579/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3579}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003580/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3580}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003581/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3581}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003582/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3582}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003583/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3583}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003584/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3584}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003585/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3585}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003586/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3586}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003587/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3587}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003588/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3588}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003589/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3589}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003590/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3590}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003591/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3591}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003592/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3592}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003593/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3593}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003594/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3594}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003595/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3595}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003596/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3596}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003597/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3597}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003598/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3598}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003599/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3599}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003600/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3600}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003601/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3601}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003602/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3602}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003603/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3603}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003604/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3604}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003605/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3605}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003606/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3606}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003607/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3607}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003608/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3608}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003609/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3609}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003610/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3610}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003611/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3611}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003612/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3612}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003613/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3613}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003614/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3614}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003615/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3615}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003616/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3616}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003617/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3617}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003618/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3618}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003619/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3619}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003620/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3620}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003621/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3621}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003622/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3622}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003623/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3623}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003624/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3624}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003625/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3625}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003626/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3626}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003627/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3627}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003628/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3628}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003629/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3629}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003630/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3630}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003631/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3631}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003632/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3632}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003633/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3633}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003634/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3634}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003635/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3635}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003636/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3636}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003637/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3637}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003638/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3638}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003639/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3639}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003640/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3640}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003641/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3641}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003642/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3642}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003643/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3643}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003644/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3644}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003645/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3645}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003646/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3646}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003647/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3647}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003648/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3648}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003649/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3649}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003650/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3650}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003651/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3651}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003652/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3652}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003653/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3653}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003654/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3654}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003655/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3655}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003656/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3656}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003657/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3657}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003658/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3658}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003659/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3659}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003660/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3660}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003661/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3661}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003662/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3662}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003663/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3663}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003664/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3664}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003665/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3665}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003666/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3666}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003667/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3667}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003668/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3668}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003669/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3669}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003670/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3670}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003671/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3671}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003672/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3672}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003673/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3673}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003674/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3674}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003675/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3675}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003676/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3676}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003677/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3677}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003678/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3678}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003679/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3679}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003680/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3680}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003681/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3681}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003682/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3682}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003683/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3683}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003684/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3684}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003685/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3685}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003686/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3686}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003687/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3687}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003688/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3688}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003689/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3689}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003690/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3690}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003691/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3691}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003692/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3692}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003693/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3693}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003694/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3694}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003695/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3695}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003696/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3696}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003697/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3697}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003698/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3698}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003699/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3699}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003700/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3700}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003701/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3701}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003702/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3702}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003703/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3703}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003704/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3704}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003705/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3705}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003706/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3706}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003707/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3707}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003708/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3708}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003709/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3709}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003710/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3710}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003711/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3711}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003712/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3712}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003713/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3713}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003714/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3714}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003715/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3715}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003716/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3716}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003717/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3717}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003718/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3718}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003719/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3719}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003720/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3720}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003721/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3721}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003722/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3722}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003723/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3723}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003724/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3724}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003725/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3725}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003726/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3726}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003727/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3727}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003728/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3728}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003729/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3729}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003730/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3730}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003731/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3731}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003732/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3732}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003733/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3733}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003734/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3734}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003735/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3735}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003736/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3736}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003737/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3737}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003738/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3738}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003739/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3739}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003740/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3740}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003741/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3741}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003742/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3742}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003743/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3743}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003744/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3744}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003745/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3745}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003746/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3746}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003747/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3747}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003748/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3748}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003749/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3749}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003750/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3750}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003751/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3751}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003752/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3752}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003753/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3753}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003754/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3754}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003755/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3755}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003756/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3756}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003757/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3757}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003758/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3758}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003759/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3759}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003760/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3760}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003761/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3761}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003762/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3762}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003763/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3763}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003764/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3764}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003765/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3765}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003766/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3766}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003767/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3767}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003768/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3768}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003769/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3769}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003770/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3770}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003771/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3771}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003772/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3772}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003773/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3773}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003774/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3774}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003775/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3775}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003776/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3776}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003777/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3777}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003778/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3778}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003779/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3779}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003780/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3780}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003781/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3781}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003782/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3782}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003783/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3783}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003784/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3784}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003785/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3785}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003786/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3786}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003787/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3787}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003788/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3788}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003789/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3789}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003790/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3790}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003791/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3791}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003792/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3792}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003793/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3793}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003794/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3794}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003795/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3795}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003796/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3796}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003797/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3797}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003798/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3798}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003799/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3799}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003800/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3800}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003801/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3801}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003802/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3802}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003803/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3803}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003804/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3804}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003805/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3805}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003806/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3806}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003807/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3807}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003808/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3808}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003809/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3809}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003810/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3810}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003811/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3811}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003812/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3812}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003813/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3813}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003814/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3814}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003815/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3815}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003816/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3816}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003817/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3817}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003818/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3818}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003819/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3819}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003820/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3820}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003821/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3821}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003822/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3822}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003823/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3823}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003824/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3824}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003825/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3825}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003826/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3826}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003827/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3827}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003828/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3828}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003829/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3829}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003830/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3830}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003831/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3831}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003832/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3832}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003833/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3833}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003834/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3834}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003835/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3835}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003836/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3836}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003837/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3837}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003838/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3838}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003839/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3839}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003840/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3840}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003841/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3841}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003842/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3842}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003843/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3843}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003844/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3844}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003845/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3845}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003846/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3846}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003847/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3847}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003848/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3848}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003849/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3849}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003850/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3850}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003851/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3851}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003852/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3852}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003853/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3853}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003854/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3854}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003855/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3855}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003856/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3856}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003857/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3857}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003858/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3858}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003859/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3859}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003860/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3860}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003861/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3861}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003862/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3862}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003863/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3863}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003864/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3864}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003865/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3865}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003866/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3866}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003867/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3867}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003868/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3868}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003869/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3869}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003870/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3870}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003871/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3871}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003872/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3872}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003873/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3873}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003874/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3874}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003875/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3875}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003876/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3876}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003877/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3877}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003878/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3878}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003879/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3879}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003880/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3880}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003881/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3881}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003882/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3882}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003883/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3883}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003884/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3884}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003885/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3885}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003886/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3886}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003887/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3887}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003888/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3888}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003889/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3889}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003890/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3890}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003891/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3891}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003892/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3892}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003893/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3893}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003894/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3894}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003895/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3895}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003896/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3896}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003897/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3897}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003898/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3898}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003899/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3899}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003900/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3900}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003901/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3901}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003902/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3902}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003903/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3903}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003904/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3904}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003905/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3905}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003906/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3906}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003907/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3907}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003908/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3908}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003909/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3909}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003910/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3910}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003911/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3911}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003912/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3912}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003913/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3913}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003914/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3914}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003915/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3915}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003916/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3916}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003917/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3917}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003918/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3918}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003919/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3919}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003920/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3920}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003921/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3921}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003922/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3922}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003923/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3923}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003924/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3924}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003925/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3925}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003926/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3926}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003927/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3927}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003928/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3928}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003929/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3929}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003930/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3930}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003931/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3931}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003932/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3932}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003933/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3933}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003934/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3934}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003935/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3935}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003936/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3936}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003937/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3937}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003938/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3938}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003939/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3939}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003940/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3940}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003941/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3941}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003942/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3942}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003943/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3943}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003944/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3944}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003945/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3945}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003946/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3946}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003947/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3947}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003948/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3948}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003949/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3949}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003950/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3950}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003951/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3951}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003952/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3952}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003953/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3953}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003954/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3954}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003955/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3955}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003956/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3956}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003957/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3957}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003958/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3958}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003959/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3959}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003960/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3960}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003961/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3961}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003962/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3962}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003963/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3963}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003964/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3964}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003965/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3965}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003966/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3966}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003967/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3967}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003968/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3968}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003969/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3969}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003970/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3970}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003971/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3971}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003972/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3972}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003973/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3973}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003974/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3974}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003975/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3975}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003976/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3976}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003977/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3977}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003978/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3978}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003979/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3979}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003980/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3980}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003981/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3981}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003982/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3982}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003983/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3983}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003984/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3984}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003985/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3985}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003986/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3986}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003987/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3987}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003988/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3988}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003989/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3989}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003990/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3990}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003991/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3991}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003992/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3992}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003993/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3993}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003994/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3994}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003995/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3995}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003996/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3996}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003997/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3997}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003998/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3998}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003999/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3999}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004000/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4000}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004001/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4001}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004002/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4002}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004003/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4003}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004004/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4004}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004005/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4005}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004006/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4006}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004007/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4007}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004008/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4008}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004009/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4009}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004010/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4010}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004011/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4011}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004012/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4012}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004013/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4013}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004014/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4014}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004015/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4015}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004016/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4016}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004017/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4017}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004018/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4018}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004019/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4019}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004020/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4020}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004021/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4021}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004022/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4022}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004023/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4023}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004024/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4024}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004025/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4025}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004026/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4026}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004027/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4027}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004028/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4028}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004029/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4029}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004030/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4030}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004031/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4031}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004032/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4032}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004033/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4033}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004034/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4034}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004035/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4035}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004036/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4036}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004037/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4037}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004038/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4038}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004039/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4039}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004040/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4040}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004041/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4041}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004042/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4042}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004043/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4043}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004044/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4044}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004045/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4045}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004046/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4046}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004047/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4047}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004048/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4048}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004049/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4049}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004050/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4050}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004051/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4051}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004052/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4052}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004053/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4053}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004054/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4054}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004055/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4055}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004056/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4056}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004057/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4057}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004058/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4058}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004059/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4059}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004060/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4060}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004061/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4061}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004062/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4062}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004063/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4063}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004064/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4064}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004065/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4065}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004066/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4066}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004067/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4067}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004068/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4068}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004069/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4069}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004070/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4070}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004071/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4071}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004072/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4072}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004073/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4073}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004074/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4074}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004075/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4075}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004076/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4076}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004077/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4077}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004078/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4078}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004079/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4079}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004080/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4080}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004081/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4081}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004082/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4082}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004083/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4083}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004084/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4084}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004085/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4085}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004086/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4086}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004087/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4087}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004088/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4088}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004089/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4089}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004090/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4090}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004091/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4091}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004092/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4092}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004093/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4093}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004094/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4094}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004095/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4095}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004096/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4096}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004097/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4097}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004098/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4098}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004099/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4099}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004100/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4100}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004101/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4101}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004102/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4102}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004103/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4103}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004104/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4104}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004105/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4105}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004106/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4106}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004107/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4107}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004108/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4108}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004109/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4109}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004110/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4110}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004111/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4111}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004112/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4112}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004113/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4113}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004114/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4114}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004115/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4115}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004116/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4116}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004117/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4117}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004118/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4118}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004119/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4119}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004120/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4120}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004121/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4121}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004122/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4122}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004123/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4123}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004124/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4124}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004125/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4125}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004126/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4126}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004127/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4127}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004128/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4128}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004129/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4129}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004130/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4130}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004131/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4131}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004132/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4132}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004133/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4133}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004134/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4134}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004135/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4135}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004136/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4136}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004137/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4137}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004138/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4138}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004139/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4139}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004140/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4140}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004141/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4141}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004142/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4142}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004143/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4143}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004144/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4144}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004145/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4145}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004146/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4146}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004147/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4147}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004148/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4148}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004149/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4149}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004150/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4150}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004151/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4151}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004152/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4152}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004153/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4153}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004154/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4154}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004155/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4155}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004156/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4156}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004157/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4157}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004158/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4158}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004159/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4159}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004160/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4160}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004161/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4161}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004162/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4162}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004163/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4163}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004164/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4164}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004165/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4165}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004166/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4166}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004167/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4167}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004168/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4168}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004169/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4169}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004170/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4170}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004171/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4171}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004172/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4172}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004173/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4173}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004174/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4174}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004175/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4175}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004176/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4176}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004177/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4177}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004178/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4178}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004179/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4179}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004180/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4180}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004181/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4181}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004182/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4182}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004183/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4183}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004184/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4184}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004185/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4185}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004186/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4186}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004187/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4187}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004188/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4188}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004189/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4189}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004190/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4190}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004191/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4191}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004192/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4192}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004193/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4193}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004194/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4194}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004195/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4195}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004196/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4196}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004197/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4197}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004198/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4198}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004199/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4199}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004200/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4200}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004201/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4201}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004202/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4202}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004203/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4203}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004204/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4204}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004205/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4205}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004206/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4206}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004207/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4207}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004208/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4208}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004209/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4209}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004210/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4210}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004211/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4211}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004212/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4212}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004213/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4213}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004214/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4214}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004215/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4215}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004216/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4216}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004217/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4217}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004218/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4218}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004219/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4219}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004220/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4220}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004221/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4221}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004222/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4222}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004223/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4223}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004224/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4224}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004225/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4225}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004226/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4226}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004227/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4227}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004228/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4228}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004229/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4229}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004230/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4230}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004231/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4231}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004232/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4232}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004233/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4233}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004234/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4234}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004235/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4235}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004236/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4236}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004237/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4237}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004238/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4238}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004239/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4239}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004240/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4240}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004241/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4241}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004242/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4242}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004243/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4243}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004244/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4244}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004245/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4245}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004246/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4246}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004247/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4247}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004248/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4248}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004249/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4249}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004250/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4250}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004251/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4251}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004252/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4252}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004253/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4253}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004254/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4254}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004255/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4255}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004256/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4256}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004257/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4257}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004258/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4258}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004259/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4259}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004260/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4260}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004261/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4261}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004262/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4262}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004263/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4263}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004264/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4264}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004265/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4265}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004266/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4266}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004267/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4267}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004268/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4268}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004269/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4269}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004270/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4270}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004271/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4271}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004272/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4272}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004273/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4273}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004274/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4274}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004275/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4275}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004276/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4276}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004277/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4277}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004278/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4278}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004279/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4279}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004280/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4280}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004281/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4281}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004282/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4282}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004283/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4283}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004284/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4284}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004285/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4285}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004286/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4286}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004287/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4287}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004288/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4288}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004289/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4289}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004290/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4290}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004291/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4291}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004292/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4292}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004293/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4293}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004294/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4294}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004295/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4295}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004296/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4296}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004297/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4297}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004298/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4298}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004299/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4299}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004300/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4300}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004301/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4301}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004302/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4302}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004303/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4303}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004304/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4304}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004305/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4305}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004306/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4306}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004307/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4307}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004308/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4308}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004309/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4309}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004310/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4310}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004311/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4311}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004312/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4312}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004313/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4313}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004314/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4314}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004315/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4315}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004316/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4316}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004317/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4317}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004318/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4318}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004319/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4319}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004320/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4320}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004321/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4321}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004322/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4322}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004323/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4323}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004324/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4324}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004325/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4325}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004326/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4326}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004327/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4327}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004328/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4328}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004329/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4329}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004330/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4330}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004331/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4331}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004332/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4332}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004333/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4333}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004334/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4334}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004335/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4335}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004336/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4336}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004337/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4337}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004338/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4338}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004339/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4339}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004340/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4340}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004341/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4341}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004342/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4342}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004343/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4343}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004344/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4344}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004345/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4345}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004346/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4346}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004347/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4347}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004348/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4348}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004349/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4349}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004350/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4350}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004351/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4351}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004352/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4352}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004353/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4353}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004354/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4354}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004355/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4355}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004356/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4356}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004357/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4357}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004358/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4358}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004359/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4359}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004360/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4360}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004361/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4361}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004362/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4362}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004363/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4363}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004364/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4364}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004365/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4365}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004366/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4366}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004367/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4367}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004368/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4368}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004369/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4369}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004370/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4370}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004371/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4371}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004372/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4372}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004373/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4373}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004374/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4374}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004375/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4375}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004376/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4376}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004377/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4377}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004378/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4378}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004379/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4379}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004380/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4380}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004381/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4381}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004382/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4382}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004383/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4383}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004384/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4384}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004385/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4385}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004386/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4386}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004387/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4387}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004388/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4388}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004389/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4389}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004390/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4390}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004391/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4391}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004392/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4392}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004393/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4393}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004394/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4394}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004395/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4395}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004396/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4396}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004397/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4397}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004398/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4398}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004399/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4399}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004400/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4400}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004401/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4401}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004402/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4402}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004403/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4403}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004404/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4404}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004405/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4405}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004406/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4406}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004407/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4407}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004408/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4408}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004409/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4409}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004410/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4410}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004411/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4411}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004412/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4412}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004413/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4413}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004414/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4414}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004415/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4415}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004416/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4416}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004417/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4417}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004418/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4418}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004419/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4419}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004420/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4420}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004421/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4421}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004422/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4422}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004423/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4423}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004424/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4424}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004425/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4425}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004426/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4426}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004427/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4427}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004428/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4428}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004429/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4429}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004430/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4430}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004431/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4431}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004432/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4432}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004433/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4433}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004434/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4434}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004435/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4435}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004436/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4436}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004437/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4437}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004438/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4438}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004439/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4439}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004440/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4440}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004441/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4441}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004442/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4442}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004443/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4443}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004444/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4444}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004445/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4445}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004446/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4446}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004447/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4447}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004448/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4448}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004449/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4449}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004450/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4450}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004451/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4451}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004452/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4452}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004453/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4453}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004454/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4454}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004455/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4455}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004456/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4456}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004457/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4457}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004458/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4458}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004459/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4459}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004460/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4460}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004461/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4461}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004462/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4462}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004463/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4463}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004464/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4464}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004465/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4465}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004466/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4466}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004467/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4467}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004468/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4468}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004469/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4469}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004470/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4470}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004471/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4471}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004472/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4472}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004473/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4473}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004474/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4474}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004475/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4475}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004476/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4476}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004477/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4477}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004478/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4478}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004479/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4479}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004480/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4480}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004481/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4481}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004482/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4482}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004483/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4483}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004484/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4484}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004485/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4485}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004486/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4486}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004487/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4487}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004488/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4488}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004489/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4489}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004490/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4490}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004491/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4491}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004492/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4492}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004493/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4493}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004494/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4494}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004495/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4495}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004496/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4496}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004497/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4497}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004498/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4498}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004499/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4499}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004500/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4500}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004501/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4501}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004502/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4502}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004503/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4503}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004504/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4504}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004505/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4505}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004506/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4506}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004507/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4507}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004508/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4508}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004509/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4509}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004510/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4510}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004511/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4511}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004512/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4512}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004513/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4513}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004514/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4514}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004515/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4515}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004516/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4516}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004517/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4517}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004518/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4518}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004519/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4519}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004520/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4520}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004521/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4521}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004522/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4522}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004523/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4523}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004524/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4524}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004525/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4525}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004526/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4526}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004527/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4527}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004528/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4528}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004529/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4529}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004530/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4530}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004531/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4531}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004532/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4532}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004533/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4533}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004534/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4534}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004535/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4535}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004536/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4536}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004537/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4537}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004538/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4538}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004539/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4539}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004540/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4540}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004541/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4541}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004542/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4542}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004543/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4543}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004544/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4544}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004545/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4545}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004546/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4546}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004547/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4547}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004548/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4548}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004549/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4549}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004550/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4550}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004551/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4551}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004552/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4552}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004553/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4553}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004554/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4554}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004555/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4555}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004556/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4556}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004557/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4557}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004558/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4558}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004559/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4559}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004560/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4560}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004561/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4561}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004562/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4562}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004563/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4563}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004564/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4564}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004565/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4565}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004566/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4566}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004567/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4567}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004568/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4568}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004569/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4569}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004570/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4570}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004571/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4571}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004572/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4572}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004573/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4573}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004574/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4574}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004575/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4575}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004576/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4576}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004577/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4577}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004578/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4578}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004579/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4579}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004580/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4580}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004581/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4581}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004582/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4582}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004583/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4583}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004584/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4584}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004585/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4585}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004586/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4586}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004587/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4587}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004588/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4588}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004589/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4589}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004590/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4590}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004591/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4591}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004592/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4592}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004593/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4593}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004594/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4594}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004595/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4595}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004596/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4596}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004597/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4597}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004598/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4598}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004599/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4599}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004600/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4600}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004601/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4601}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004602/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4602}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004603/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4603}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004604/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4604}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004605/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4605}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004606/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4606}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004607/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4607}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004608/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4608}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004609/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4609}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004610/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4610}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004611/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4611}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004612/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4612}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004613/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4613}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004614/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4614}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004615/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4615}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004616/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4616}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004617/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4617}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004618/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4618}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004619/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4619}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004620/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4620}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004621/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4621}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004622/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4622}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004623/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4623}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004624/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4624}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004625/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4625}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004626/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4626}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004627/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4627}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004628/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4628}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004629/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4629}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004630/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4630}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004631/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4631}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004632/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4632}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004633/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4633}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004634/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4634}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004635/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4635}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004636/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4636}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004637/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4637}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004638/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4638}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004639/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4639}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004640/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4640}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004641/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4641}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004642/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4642}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004643/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4643}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004644/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4644}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004645/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4645}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004646/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4646}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004647/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4647}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004648/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4648}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004649/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4649}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004650/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4650}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004651/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4651}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004652/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4652}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004653/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4653}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004654/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4654}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004655/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4655}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004656/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4656}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004657/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4657}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004658/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4658}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004659/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4659}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004660/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4660}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004661/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4661}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004662/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4662}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004663/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4663}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004664/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4664}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004665/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4665}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004666/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4666}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004667/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4667}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004668/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4668}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004669/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4669}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004670/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4670}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004671/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4671}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004672/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4672}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004673/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4673}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004674/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4674}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004675/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4675}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004676/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4676}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004677/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4677}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004678/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4678}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004679/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4679}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004680/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4680}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004681/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4681}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004682/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4682}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004683/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4683}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004684/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4684}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004685/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4685}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004686/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4686}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004687/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4687}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004688/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4688}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004689/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4689}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004690/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4690}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004691/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4691}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004692/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4692}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004693/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4693}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004694/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4694}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004695/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4695}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004696/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4696}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004697/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4697}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004698/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4698}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004699/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4699}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004700/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4700}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004701/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4701}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004702/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4702}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004703/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4703}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004704/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4704}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004705/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4705}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004706/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4706}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004707/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4707}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004708/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4708}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004709/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4709}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004710/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4710}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004711/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4711}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004712/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4712}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004713/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4713}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004714/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4714}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004715/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4715}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004716/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4716}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004717/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4717}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004718/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4718}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004719/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4719}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004720/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4720}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004721/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4721}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004722/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4722}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004723/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4723}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004724/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4724}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004725/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4725}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004726/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4726}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004727/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4727}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004728/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4728}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004729/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4729}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004730/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4730}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004731/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4731}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004732/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4732}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004733/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4733}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004734/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4734}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004735/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4735}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004736/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4736}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004737/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4737}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004738/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4738}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004739/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4739}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004740/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4740}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004741/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … ��� a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4741}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004742/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4742}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004743/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4743}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004744/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4744}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004745/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4745}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004746/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4746}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004747/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4747}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004748/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4748}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004749/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4749}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004750/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4750}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004751/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4751}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004752/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4752}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004753/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4753}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004754/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4754}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004755/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4755}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004756/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4756}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004757/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4757}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004758/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4758}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004759/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4759}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004760/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4760}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004761/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4761}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004762/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4762}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004763/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4763}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004764/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4764}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004765/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4765}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004766/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4766}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004767/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4767}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004768/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4768}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004769/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4769}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004770/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4770}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004771/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4771}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004772/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4772}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004773/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4773}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004774/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4774}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004775/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4775}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004776/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4776}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004777/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4777}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004778/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4778}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004779/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4779}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004780/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4780}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004781/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4781}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004782/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4782}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004783/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4783}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004784/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4784}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004785/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4785}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004786/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4786}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004787/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4787}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004788/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4788}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004789/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4789}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004790/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4790}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004791/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4791}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004792/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4792}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004793/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4793}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004794/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4794}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004795/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4795}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004796/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4796}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004797/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4797}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004798/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4798}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004799/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4799}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004800/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4800}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004801/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4801}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004802/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4802}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004803/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4803}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004804/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4804}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004805/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4805}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004806/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4806}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004807/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4807}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004808/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4808}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004809/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4809}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004810/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4810}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004811/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4811}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004812/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4812}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004813/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4813}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004814/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4814}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004815/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4815}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004816/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4816}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004817/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4817}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004818/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4818}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004819/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4819}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004820/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4820}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004821/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4821}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004822/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4822}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004823/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4823}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004824/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4824}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004825/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4825}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004826/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4826}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004827/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4827}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004828/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4828}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004829/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4829}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004830/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4830}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004831/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4831}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004832/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4832}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004833/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4833}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004834/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4834}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004835/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4835}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004836/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4836}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004837/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4837}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004838/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4838}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004839/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4839}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004840/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4840}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004841/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4841}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004842/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4842}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004843/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4843}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004844/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4844}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004845/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4845}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004846/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4846}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004847/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4847}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004848/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4848}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004849/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4849}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004850/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4850}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004851/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4851}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004852/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4852}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004853/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4853}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004854/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4854}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004855/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4855}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004856/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4856}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004857/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4857}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004858/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4858}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004859/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4859}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004860/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4860}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004861/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4861}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004862/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4862}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004863/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4863}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004864/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4864}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004865/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4865}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004866/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4866}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004867/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4867}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004868/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4868}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004869/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4869}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004870/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4870}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004871/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4871}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004872/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4872}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004873/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4873}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004874/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4874}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004875/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4875}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004876/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4876}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004877/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4877}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004878/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4878}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004879/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4879}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004880/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4880}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004881/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4881}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004882/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4882}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004883/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4883}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004884/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4884}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004885/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4885}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004886/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4886}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004887/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4887}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004888/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4888}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004889/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4889}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004890/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4890}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004891/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4891}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004892/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4892}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004893/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4893}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004894/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4894}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004895/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4895}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004896/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4896}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004897/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4897}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004898/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4898}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004899/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4899}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004900/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4900}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004901/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4901}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004902/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4902}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004903/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4903}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004904/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4904}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004905/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4905}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004906/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4906}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004907/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4907}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004908/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4908}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004909/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4909}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004910/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4910}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004911/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4911}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004912/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4912}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004913/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4913}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004914/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4914}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004915/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4915}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004916/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4916}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004917/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4917}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004918/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4918}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004919/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4919}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004920/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4920}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004921/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4921}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004922/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4922}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004923/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4923}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004924/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4924}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004925/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4925}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004926/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4926}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004927/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4927}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004928/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4928}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004929/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4929}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004930/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4930}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004931/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4931}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004932/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4932}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004933/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4933}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004934/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4934}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004935/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4935}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004936/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4936}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004937/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4937}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004938/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4938}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004939/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4939}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004940/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4940}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004941/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4941}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004942/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4942}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004943/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4943}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004944/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4944}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004945/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4945}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004946/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4946}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004947/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4947}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004948/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4948}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004949/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4949}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004950/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4950}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004951/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4951}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004952/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4952}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004953/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4953}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004954/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4954}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004955/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4955}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004956/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4956}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004957/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4957}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004958/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4958}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004959/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4959}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004960/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4960}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004961/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4961}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004962/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4962}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004963/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4963}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004964/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4964}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004965/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4965}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004966/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4966}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004967/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4967}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004968/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4968}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004969/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4969}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004970/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4970}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004971/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4971}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004972/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4972}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004973/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4973}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004974/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4974}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004975/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4975}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004976/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4976}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004977/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4977}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004978/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4978}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004979/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4979}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004980/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4980}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004981/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4981}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004982/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4982}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004983/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4983}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004984/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4984}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004985/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4985}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004986/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4986}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004987/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4987}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004988/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4988}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004989/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4989}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004990/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4990}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004991/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4991}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004992/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4992}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004993/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4993}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004994/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4994}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004995/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4995}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004996/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4996}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004997/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4997}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004998/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4998}
-{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004999/video/ground_truth.mp4", "length": 128, "fps": 16, "width": 1024, "height": 1024, "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4999}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000000/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 0}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000001/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000002/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000003/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000004/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000005/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 5}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000006/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 6}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000007/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 7}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000008/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 8}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000009/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 9}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000010/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 10}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000011/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 11}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000012/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 12}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000013/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 13}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000014/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 14}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000015/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 15}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000016/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 16}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000017/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 17}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000018/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 18}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000019/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 19}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000020/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 20}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000021/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 21}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000022/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 22}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000023/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 23}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000024/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 24}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000025/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 25}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000026/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 26}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000027/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 27}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000028/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 28}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000029/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 29}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000030/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 30}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000031/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 31}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000032/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 32}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000033/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 33}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000034/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 34}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000035/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 35}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000036/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 36}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000037/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 37}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000038/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 38}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000039/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 39}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000040/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 40}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000041/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 41}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000042/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 42}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000043/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 43}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000044/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 44}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000045/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 45}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000046/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 46}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000047/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 47}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000048/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 48}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000049/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 49}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000050/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 50}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000051/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 51}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000052/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 52}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000053/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 53}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000054/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 54}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000055/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 55}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000056/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 56}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000057/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 57}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000058/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 58}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000059/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 59}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000060/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 60}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000061/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 61}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000062/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 62}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000063/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 63}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000064/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 64}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000065/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 65}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000066/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 66}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000067/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 67}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000068/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 68}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000069/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 69}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000070/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 70}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000071/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 71}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000072/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 72}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000073/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 73}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000074/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 74}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000075/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 75}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000076/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 76}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000077/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 77}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000078/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 78}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000079/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 79}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000080/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 80}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000081/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 81}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000082/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 82}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000083/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 83}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000084/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 84}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000085/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 85}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000086/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 86}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000087/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 87}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000088/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 88}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000089/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 89}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000090/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 90}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000091/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 91}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000092/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 92}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000093/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 93}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000094/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 94}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000095/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 95}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000096/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 96}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000097/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 97}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000098/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 98}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000099/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 99}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000100/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 100}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000101/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 101}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000102/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 102}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000103/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 103}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000104/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 104}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000105/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 105}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000106/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 106}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000107/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 107}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000108/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 108}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000109/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 109}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000110/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 110}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000111/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 111}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000112/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 112}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000113/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 113}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000114/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 114}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000115/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 115}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000116/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 116}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000117/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 117}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000118/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 118}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000119/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 119}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000120/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 120}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000121/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 121}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000122/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 122}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000123/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 123}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000124/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 124}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000125/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 125}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000126/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 126}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000127/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 127}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000128/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 128}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000129/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 129}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000130/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 130}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000131/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 131}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000132/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 132}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000133/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 133}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000134/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 134}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000135/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 135}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000136/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 136}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000137/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 137}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000138/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 138}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000139/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 139}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000140/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 140}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000141/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 141}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000142/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 142}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000143/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 143}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000144/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 144}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000145/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 145}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000146/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 146}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000147/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 147}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000148/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 148}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000149/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 149}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000150/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 150}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000151/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 151}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000152/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 152}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000153/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 153}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000154/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 154}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000155/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 155}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000156/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 156}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000157/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 157}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000158/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 158}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000159/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 159}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000160/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 160}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000161/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 161}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000162/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 162}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000163/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 163}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000164/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 164}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000165/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 165}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000166/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 166}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000167/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 167}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000168/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 168}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000169/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 169}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000170/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 170}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000171/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 171}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000172/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 172}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000173/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 173}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000174/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 174}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000175/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 175}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000176/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 176}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000177/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 177}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000178/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 178}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000179/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 179}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000180/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 180}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000181/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 181}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000182/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 182}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000183/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 183}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000184/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 184}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000185/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 185}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000186/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 186}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000187/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 187}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000188/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 188}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000189/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 189}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000190/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 190}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000191/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 191}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000192/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 192}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000193/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 193}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000194/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 194}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000195/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 195}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000196/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 196}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000197/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 197}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000198/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 198}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000199/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 199}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000200/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 200}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000201/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 201}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000202/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 202}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000203/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 203}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000204/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 204}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000205/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 205}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000206/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 206}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000207/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 207}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000208/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 208}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000209/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 209}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000210/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 210}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000211/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 211}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000212/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 212}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000213/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 213}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000214/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 214}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000215/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 215}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000216/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 216}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000217/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 217}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000218/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 218}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000219/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 219}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000220/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 220}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000221/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 221}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000222/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 222}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000223/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 223}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000224/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 224}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000225/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 225}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000226/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 226}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000227/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 227}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000228/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 228}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000229/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 229}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000230/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 230}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000231/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 231}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000232/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 232}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000233/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 233}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000234/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 234}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000235/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 235}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000236/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 236}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000237/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 237}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000238/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 238}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000239/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 239}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000240/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 240}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000241/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 241}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000242/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 242}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000243/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 243}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000244/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 244}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000245/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 245}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000246/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 246}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000247/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 247}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000248/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 248}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000249/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 249}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000250/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 250}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000251/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 251}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000252/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 252}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000253/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 253}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000254/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 254}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000255/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 255}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000256/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 256}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000257/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 257}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000258/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 258}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000259/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 259}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000260/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 260}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000261/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 261}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000262/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 262}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000263/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 263}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000264/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 264}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000265/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 265}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000266/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 266}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000267/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 267}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000268/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 268}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000269/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 269}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000270/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 270}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000271/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 271}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000272/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 272}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000273/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 273}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000274/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 274}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000275/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 275}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000276/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 276}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000277/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 277}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000278/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 278}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000279/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 279}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000280/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 280}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000281/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 281}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000282/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 282}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000283/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 283}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000284/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 284}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000285/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 285}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000286/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 286}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000287/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 287}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000288/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 288}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000289/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 289}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000290/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 290}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000291/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 291}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000292/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 292}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000293/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 293}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000294/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 294}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000295/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 295}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000296/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 296}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000297/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 297}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000298/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 298}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000299/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 299}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000300/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 300}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000301/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 301}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000302/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 302}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000303/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 303}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000304/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 304}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000305/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 305}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000306/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 306}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000307/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 307}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000308/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 308}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000309/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 309}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000310/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 310}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000311/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 311}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000312/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 312}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000313/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 313}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000314/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 314}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000315/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 315}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000316/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 316}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000317/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 317}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000318/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 318}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000319/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 319}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000320/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 320}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000321/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 321}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000322/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 322}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000323/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 323}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000324/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 324}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000325/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 325}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000326/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 326}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000327/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 327}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000328/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 328}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000329/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 329}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000330/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 330}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000331/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 331}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000332/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 332}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000333/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 333}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000334/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 334}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000335/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 335}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000336/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 336}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000337/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 337}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000338/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 338}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000339/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 339}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000340/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 340}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000341/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 341}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000342/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 342}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000343/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 343}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000344/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 344}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000345/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 345}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000346/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 346}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000347/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 347}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000348/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 348}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000349/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 349}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000350/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 350}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000351/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 351}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000352/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 352}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000353/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 353}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000354/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 354}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000355/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 355}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000356/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 356}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000357/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 357}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000358/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 358}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000359/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 359}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000360/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 360}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000361/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 361}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000362/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 362}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000363/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 363}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000364/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 364}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000365/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 365}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000366/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 366}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000367/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 367}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000368/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 368}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000369/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 369}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000370/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 370}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000371/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 371}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000372/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 372}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000373/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 373}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000374/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 374}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000375/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 375}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000376/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 376}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000377/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 377}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000378/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 378}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000379/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 379}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000380/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 380}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000381/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 381}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000382/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 382}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000383/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 383}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000384/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 384}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000385/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 385}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000386/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 386}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000387/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 387}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000388/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 388}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000389/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 389}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000390/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 390}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000391/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 391}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000392/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 392}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000393/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 393}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000394/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 394}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000395/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 395}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000396/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 396}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000397/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 397}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000398/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 398}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000399/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 399}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000400/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 400}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000401/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 401}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000402/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 402}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000403/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 403}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000404/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 404}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000405/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 405}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000406/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 406}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000407/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 407}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000408/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 408}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000409/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 409}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000410/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 410}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000411/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 411}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000412/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 412}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000413/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 413}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000414/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 414}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000415/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 415}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000416/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 416}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000417/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 417}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000418/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 418}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000419/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 419}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000420/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 420}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000421/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 421}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000422/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 422}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000423/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 423}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000424/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 424}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000425/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 425}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000426/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 426}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000427/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 427}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000428/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 428}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000429/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 429}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000430/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 430}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000431/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 431}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000432/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 432}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000433/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 433}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000434/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 434}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000435/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 435}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000436/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 436}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000437/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 437}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000438/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 438}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000439/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 439}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000440/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 440}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000441/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 441}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000442/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 442}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000443/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 443}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000444/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 444}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000445/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 445}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000446/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 446}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000447/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 447}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000448/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 448}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000449/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 449}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000450/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 450}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000451/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 451}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000452/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 452}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000453/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 453}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000454/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 454}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000455/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 455}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000456/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 456}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000457/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 457}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000458/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 458}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000459/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 459}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000460/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 460}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000461/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 461}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000462/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 462}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000463/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 463}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000464/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 464}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000465/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 465}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000466/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 466}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000467/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 467}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000468/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 468}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000469/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 469}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000470/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 470}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000471/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 471}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000472/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 472}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000473/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 473}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000474/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 474}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000475/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 475}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000476/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 476}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000477/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 477}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000478/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 478}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000479/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 479}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000480/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 480}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000481/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 481}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000482/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 482}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000483/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 483}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000484/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 484}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000485/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 485}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000486/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 486}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000487/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 487}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000488/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 488}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000489/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 489}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000490/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 490}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000491/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 491}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000492/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 492}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000493/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 493}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000494/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 494}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000495/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 495}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000496/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 496}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000497/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 497}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000498/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 498}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000499/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 499}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000500/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 500}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000501/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 501}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000502/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 502}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000503/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 503}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000504/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 504}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000505/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 505}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000506/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 506}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000507/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 507}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000508/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 508}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000509/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 509}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000510/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 510}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000511/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 511}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000512/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 512}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000513/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 513}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000514/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 514}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000515/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 515}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000516/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 516}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000517/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 517}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000518/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 518}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000519/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 519}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000520/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 520}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000521/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 521}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000522/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 522}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000523/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 523}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000524/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 524}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000525/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 525}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000526/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 526}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000527/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 527}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000528/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 528}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000529/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 529}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000530/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 530}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000531/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 531}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000532/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 532}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000533/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 533}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000534/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 534}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000535/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 535}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000536/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 536}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000537/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 537}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000538/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 538}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000539/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 539}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000540/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 540}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000541/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 541}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000542/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 542}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000543/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 543}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000544/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 544}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000545/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 545}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000546/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 546}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000547/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 547}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000548/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 548}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000549/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 549}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000550/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 550}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000551/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 551}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000552/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 552}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000553/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 553}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000554/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 554}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000555/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 555}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000556/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 556}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000557/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 557}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000558/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 558}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000559/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 559}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000560/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 560}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000561/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 561}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000562/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 562}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000563/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 563}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000564/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 564}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000565/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 565}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000566/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 566}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000567/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 567}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000568/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 568}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000569/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 569}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000570/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 570}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000571/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 571}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000572/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 572}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000573/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 573}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000574/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 574}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000575/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 575}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000576/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 576}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000577/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 577}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000578/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 578}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000579/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 579}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000580/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 580}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000581/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 581}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000582/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 582}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000583/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 583}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000584/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 584}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000585/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 585}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000586/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 586}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000587/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 587}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000588/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 588}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000589/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 589}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000590/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 590}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000591/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 591}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000592/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 592}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000593/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 593}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000594/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 594}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000595/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 595}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000596/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 596}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000597/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 597}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000598/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 598}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000599/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 599}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000600/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 600}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000601/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 601}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000602/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 602}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000603/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 603}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000604/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 604}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000605/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 605}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000606/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 606}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000607/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 607}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000608/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 608}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000609/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 609}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000610/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 610}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000611/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 611}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000612/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 612}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000613/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 613}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000614/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 614}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000615/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 615}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000616/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 616}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000617/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 617}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000618/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 618}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000619/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 619}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000620/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 620}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000621/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 621}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000622/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 622}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000623/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 623}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000624/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 624}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000625/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 625}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000626/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 626}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000627/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 627}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000628/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 628}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000629/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 629}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000630/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 630}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000631/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 631}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000632/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 632}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000633/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 633}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000634/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 634}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000635/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 635}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000636/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 636}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000637/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 637}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000638/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 638}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000639/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 639}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000640/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 640}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000641/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 641}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000642/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 642}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000643/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 643}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000644/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 644}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000645/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 645}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000646/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 646}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000647/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 647}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000648/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 648}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000649/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 649}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000650/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 650}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000651/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 651}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000652/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 652}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000653/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 653}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000654/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 654}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000655/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 655}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000656/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 656}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000657/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 657}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000658/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 658}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000659/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 659}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000660/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 660}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000661/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 661}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000662/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 662}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000663/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 663}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000664/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 664}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000665/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 665}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000666/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 666}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000667/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 667}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000668/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 668}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000669/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 669}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000670/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 670}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000671/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 671}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000672/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 672}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000673/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 673}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000674/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 674}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000675/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 675}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000676/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 676}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000677/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 677}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000678/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 678}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000679/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 679}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000680/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 680}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000681/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 681}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000682/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 682}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000683/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 683}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000684/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 684}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000685/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 685}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000686/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 686}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000687/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 687}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000688/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 688}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000689/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 689}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000690/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 690}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000691/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 691}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000692/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 692}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000693/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 693}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000694/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 694}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000695/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 695}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000696/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 696}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000697/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 697}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000698/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 698}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000699/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 699}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000700/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 700}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000701/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 701}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000702/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 702}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000703/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 703}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000704/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 704}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000705/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 705}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000706/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 706}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000707/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 707}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000708/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 708}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000709/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 709}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000710/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 710}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000711/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 711}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000712/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 712}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000713/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 713}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000714/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 714}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000715/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 715}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000716/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 716}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000717/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 717}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000718/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 718}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000719/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 719}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000720/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 720}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000721/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 721}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000722/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 722}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000723/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 723}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000724/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 724}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000725/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 725}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000726/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 726}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000727/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 727}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000728/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 728}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000729/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 729}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000730/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 730}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000731/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 731}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000732/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 732}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000733/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 733}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000734/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 734}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000735/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 735}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000736/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 736}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000737/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 737}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000738/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 738}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000739/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 739}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000740/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 740}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000741/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 741}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000742/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 742}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000743/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 743}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000744/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 744}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000745/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 745}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000746/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 746}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000747/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 747}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000748/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 748}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000749/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 749}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000750/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 750}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000751/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 751}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000752/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 752}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000753/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 753}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000754/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 754}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000755/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 755}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000756/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 756}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000757/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 757}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000758/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 758}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000759/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 759}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000760/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 760}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000761/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 761}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000762/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 762}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000763/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 763}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000764/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 764}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000765/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 765}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000766/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 766}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000767/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 767}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000768/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 768}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000769/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 769}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000770/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 770}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000771/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 771}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000772/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 772}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000773/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 773}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000774/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 774}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000775/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 775}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000776/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 776}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000777/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 777}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000778/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 778}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000779/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 779}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000780/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 780}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000781/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 781}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000782/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 782}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000783/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 783}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000784/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 784}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000785/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 785}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000786/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 786}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000787/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 787}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000788/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 788}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000789/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 789}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000790/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 790}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000791/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 791}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000792/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 792}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000793/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 793}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000794/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 794}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000795/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 795}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000796/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 796}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000797/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 797}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000798/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 798}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000799/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 799}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000800/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 800}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000801/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 801}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000802/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 802}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000803/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 803}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000804/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 804}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000805/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 805}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000806/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 806}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000807/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 807}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000808/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 808}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000809/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 809}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000810/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 810}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000811/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 811}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000812/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 812}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000813/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 813}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000814/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 814}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000815/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 815}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000816/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 816}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000817/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 817}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000818/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 818}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000819/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 819}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000820/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 820}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000821/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 821}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000822/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 822}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000823/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 823}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000824/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 824}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000825/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 825}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000826/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 826}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000827/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 827}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000828/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 828}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000829/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 829}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000830/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 830}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000831/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 831}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000832/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 832}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000833/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 833}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000834/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 834}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000835/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 835}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000836/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 836}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000837/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 837}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000838/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 838}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000839/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 839}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000840/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 840}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000841/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 841}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000842/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 842}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000843/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 843}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000844/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 844}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000845/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 845}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000846/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 846}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000847/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 847}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000848/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 848}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000849/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 849}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000850/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 850}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000851/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 851}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000852/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 852}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000853/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 853}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000854/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 854}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000855/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 855}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000856/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 856}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000857/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 857}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000858/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 858}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000859/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 859}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000860/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 860}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000861/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 861}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000862/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 862}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000863/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 863}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000864/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 864}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000865/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 865}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000866/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 866}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000867/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 867}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000868/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 868}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000869/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 869}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000870/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 870}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000871/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 871}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000872/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 872}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000873/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 873}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000874/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 874}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000875/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 875}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000876/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 876}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000877/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 877}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000878/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 878}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000879/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 879}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000880/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 880}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000881/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 881}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000882/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 882}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000883/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 883}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000884/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 884}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000885/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 885}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000886/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 886}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000887/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 887}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000888/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 888}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000889/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 889}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000890/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 890}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000891/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 891}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000892/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 892}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000893/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 893}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000894/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 894}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000895/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 895}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000896/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 896}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000897/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 897}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000898/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 898}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000899/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 899}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000900/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 900}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000901/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 901}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000902/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 902}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000903/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 903}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000904/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 904}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000905/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 905}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000906/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 906}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000907/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 907}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000908/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 908}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000909/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 909}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000910/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 910}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000911/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 911}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000912/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 912}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000913/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 913}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000914/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 914}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000915/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 915}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000916/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 916}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000917/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 917}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000918/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 918}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000919/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 919}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000920/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 920}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000921/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 921}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000922/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 922}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000923/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 923}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000924/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 924}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000925/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 925}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000926/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 926}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000927/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 927}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000928/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 928}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000929/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 929}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000930/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 930}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000931/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 931}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000932/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 932}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000933/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 933}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000934/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 934}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000935/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 935}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000936/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 936}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000937/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 937}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000938/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 938}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000939/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 939}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000940/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 940}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000941/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 941}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000942/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 942}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000943/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 943}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000944/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 944}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000945/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 945}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000946/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 946}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000947/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 947}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000948/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 948}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000949/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 949}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000950/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 950}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000951/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 951}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000952/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 952}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000953/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 953}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000954/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 954}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000955/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 955}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000956/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 956}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000957/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 957}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000958/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 958}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000959/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 959}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000960/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 960}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000961/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 961}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000962/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 962}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000963/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 963}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000964/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 964}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000965/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 965}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000966/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 966}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000967/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 967}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000968/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 968}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000969/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 969}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000970/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 970}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000971/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 971}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000972/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 972}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000973/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 973}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000974/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 974}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000975/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 975}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000976/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 976}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000977/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 977}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000978/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 978}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000979/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 979}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000980/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 980}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000981/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 981}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000982/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 982}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000983/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 983}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000984/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 984}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000985/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 985}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000986/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 986}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000987/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 987}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000988/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 988}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000989/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 989}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000990/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 990}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000991/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 991}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000992/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 992}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000993/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 993}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000994/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 994}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000995/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 995}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000996/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 996}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000997/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 997}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000998/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 998}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00000999/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 999}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001000/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1000}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001001/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1001}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001002/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1002}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001003/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1003}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001004/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1004}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001005/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1005}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001006/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1006}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001007/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1007}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001008/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1008}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001009/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1009}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001010/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1010}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001011/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1011}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001012/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1012}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001013/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1013}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001014/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1014}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001015/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1015}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001016/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1016}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001017/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1017}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001018/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1018}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001019/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1019}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001020/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1020}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001021/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1021}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001022/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1022}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001023/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1023}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001024/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1024}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001025/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1025}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001026/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1026}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001027/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1027}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001028/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1028}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001029/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1029}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001030/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1030}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001031/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1031}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001032/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1032}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001033/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1033}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001034/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1034}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001035/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1035}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001036/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1036}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001037/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1037}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001038/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1038}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001039/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1039}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001040/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1040}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001041/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1041}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001042/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1042}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001043/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1043}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001044/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1044}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001045/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1045}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001046/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1046}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001047/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1047}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001048/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1048}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001049/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1049}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001050/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1050}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001051/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1051}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001052/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1052}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001053/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1053}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001054/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1054}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001055/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1055}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001056/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1056}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001057/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1057}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001058/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1058}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001059/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1059}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001060/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1060}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001061/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1061}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001062/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1062}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001063/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1063}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001064/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1064}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001065/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1065}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001066/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1066}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001067/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1067}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001068/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1068}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001069/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1069}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001070/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1070}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001071/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1071}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001072/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1072}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001073/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1073}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001074/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1074}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001075/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1075}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001076/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1076}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001077/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1077}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001078/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1078}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001079/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1079}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001080/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1080}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001081/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1081}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001082/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1082}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001083/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1083}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001084/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1084}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001085/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1085}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001086/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1086}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001087/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1087}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001088/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1088}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001089/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1089}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001090/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1090}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001091/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1091}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001092/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1092}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001093/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1093}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001094/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1094}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001095/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1095}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001096/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1096}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001097/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1097}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001098/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1098}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001099/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1099}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001100/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1100}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001101/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1101}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001102/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1102}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001103/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1103}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001104/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1104}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001105/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1105}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001106/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1106}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001107/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1107}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001108/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1108}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001109/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1109}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001110/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1110}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001111/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1111}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001112/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1112}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001113/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1113}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001114/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1114}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001115/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1115}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001116/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1116}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001117/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1117}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001118/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1118}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001119/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1119}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001120/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1120}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001121/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1121}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001122/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1122}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001123/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1123}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001124/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1124}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001125/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1125}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001126/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1126}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001127/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1127}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001128/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1128}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001129/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1129}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001130/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1130}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001131/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1131}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001132/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1132}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001133/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1133}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001134/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1134}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001135/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1135}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001136/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1136}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001137/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1137}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001138/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1138}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001139/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1139}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001140/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1140}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001141/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1141}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001142/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1142}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001143/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1143}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001144/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1144}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001145/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1145}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001146/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1146}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001147/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1147}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001148/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1148}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001149/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1149}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001150/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1150}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001151/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1151}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001152/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1152}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001153/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, ��� — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1153}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001154/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1154}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001155/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1155}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001156/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1156}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001157/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1157}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001158/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1158}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001159/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1159}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001160/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1160}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001161/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1161}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001162/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1162}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001163/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1163}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001164/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1164}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001165/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1165}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001166/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1166}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001167/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1167}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001168/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1168}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001169/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1169}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001170/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1170}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001171/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1171}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001172/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1172}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001173/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1173}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001174/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1174}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001175/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1175}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001176/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1176}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001177/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1177}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001178/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1178}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001179/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1179}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001180/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1180}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001181/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1181}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001182/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1182}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001183/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1183}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001184/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1184}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001185/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1185}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001186/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1186}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001187/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1187}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001188/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1188}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001189/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1189}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001190/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1190}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001191/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1191}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001192/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1192}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001193/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1193}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001194/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1194}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001195/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1195}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001196/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1196}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001197/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1197}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001198/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1198}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001199/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1199}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001200/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1200}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001201/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1201}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001202/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1202}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001203/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1203}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001204/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1204}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001205/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1205}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001206/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1206}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001207/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1207}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001208/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1208}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001209/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1209}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001210/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1210}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001211/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1211}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001212/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1212}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001213/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1213}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001214/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1214}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001215/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1215}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001216/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1216}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001217/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1217}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001218/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1218}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001219/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1219}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001220/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1220}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001221/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1221}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001222/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1222}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001223/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1223}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001224/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1224}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001225/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1225}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001226/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1226}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001227/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1227}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001228/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1228}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001229/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1229}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001230/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1230}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001231/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1231}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001232/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1232}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001233/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1233}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001234/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1234}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001235/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1235}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001236/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1236}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001237/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1237}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001238/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1238}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001239/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1239}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001240/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1240}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001241/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1241}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001242/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1242}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001243/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1243}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001244/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1244}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001245/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1245}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001246/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1246}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001247/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1247}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001248/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1248}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001249/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1249}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001250/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1250}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001251/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1251}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001252/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1252}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001253/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1253}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001254/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1254}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001255/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1255}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001256/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1256}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001257/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1257}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001258/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1258}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001259/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1259}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001260/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1260}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001261/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1261}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001262/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1262}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001263/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1263}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001264/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1264}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001265/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1265}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001266/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1266}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001267/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1267}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001268/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1268}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001269/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1269}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001270/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1270}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001271/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1271}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001272/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1272}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001273/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1273}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001274/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1274}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001275/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1275}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001276/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1276}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001277/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1277}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001278/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1278}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001279/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1279}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001280/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1280}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001281/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1281}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001282/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1282}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001283/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1283}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001284/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1284}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001285/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1285}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001286/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1286}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001287/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1287}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001288/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1288}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001289/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1289}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001290/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1290}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001291/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1291}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001292/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1292}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001293/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1293}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001294/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1294}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001295/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1295}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001296/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1296}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001297/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1297}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001298/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1298}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001299/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1299}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001300/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1300}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001301/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1301}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001302/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1302}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001303/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1303}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001304/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1304}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001305/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1305}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001306/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1306}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001307/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1307}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001308/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1308}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001309/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1309}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001310/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1310}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001311/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1311}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001312/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1312}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001313/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1313}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001314/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1314}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001315/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1315}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001316/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1316}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001317/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1317}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001318/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1318}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001319/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1319}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001320/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1320}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001321/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1321}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001322/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1322}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001323/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1323}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001324/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1324}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001325/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1325}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001326/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1326}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001327/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1327}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001328/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1328}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001329/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1329}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001330/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1330}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001331/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1331}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001332/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1332}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001333/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1333}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001334/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1334}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001335/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1335}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001336/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1336}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001337/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1337}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001338/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1338}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001339/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1339}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001340/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1340}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001341/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1341}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001342/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1342}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001343/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1343}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001344/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1344}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001345/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1345}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001346/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1346}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001347/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1347}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001348/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1348}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001349/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1349}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001350/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1350}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001351/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1351}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001352/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1352}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001353/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1353}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001354/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1354}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001355/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1355}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001356/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1356}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001357/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1357}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001358/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1358}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001359/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1359}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001360/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1360}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001361/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1361}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001362/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1362}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001363/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1363}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001364/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1364}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001365/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1365}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001366/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1366}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001367/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1367}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001368/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1368}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001369/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1369}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001370/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1370}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001371/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1371}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001372/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1372}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001373/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1373}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001374/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1374}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001375/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1375}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001376/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1376}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001377/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1377}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001378/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1378}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001379/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1379}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001380/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1380}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001381/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1381}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001382/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1382}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001383/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1383}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001384/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1384}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001385/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1385}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001386/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1386}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001387/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1387}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001388/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1388}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001389/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1389}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001390/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1390}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001391/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1391}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001392/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1392}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001393/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1393}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001394/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1394}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001395/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1395}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001396/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1396}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001397/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1397}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001398/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1398}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001399/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1399}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001400/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1400}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001401/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1401}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001402/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1402}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001403/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1403}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001404/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1404}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001405/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1405}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001406/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1406}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001407/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1407}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001408/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1408}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001409/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1409}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001410/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1410}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001411/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1411}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001412/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1412}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001413/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1413}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001414/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1414}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001415/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1415}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001416/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1416}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001417/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1417}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001418/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1418}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001419/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1419}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001420/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1420}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001421/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1421}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001422/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1422}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001423/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1423}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001424/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1424}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001425/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1425}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001426/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1426}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001427/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1427}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001428/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1428}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001429/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1429}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001430/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1430}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001431/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1431}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001432/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1432}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001433/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1433}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001434/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1434}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001435/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1435}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001436/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1436}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001437/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1437}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001438/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1438}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001439/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1439}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001440/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1440}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001441/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1441}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001442/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1442}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001443/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1443}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001444/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1444}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001445/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1445}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001446/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1446}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001447/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1447}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001448/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1448}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001449/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1449}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001450/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1450}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001451/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1451}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001452/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1452}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001453/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1453}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001454/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1454}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001455/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1455}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001456/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1456}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001457/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1457}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001458/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1458}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001459/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1459}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001460/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1460}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001461/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1461}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001462/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1462}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001463/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1463}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001464/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1464}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001465/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1465}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001466/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1466}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001467/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1467}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001468/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1468}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001469/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1469}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001470/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1470}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001471/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1471}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001472/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1472}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001473/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1473}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001474/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1474}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001475/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1475}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001476/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1476}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001477/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1477}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001478/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1478}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001479/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1479}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001480/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1480}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001481/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1481}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001482/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1482}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001483/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1483}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001484/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1484}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001485/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1485}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001486/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1486}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001487/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1487}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001488/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1488}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001489/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1489}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001490/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1490}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001491/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1491}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001492/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1492}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001493/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1493}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001494/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1494}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001495/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1495}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001496/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1496}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001497/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1497}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001498/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1498}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001499/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1499}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001500/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1500}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001501/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1501}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001502/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1502}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001503/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1503}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001504/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1504}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001505/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1505}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001506/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1506}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001507/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1507}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001508/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1508}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001509/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1509}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001510/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1510}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001511/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1511}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001512/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1512}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001513/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1513}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001514/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1514}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001515/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1515}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001516/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1516}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001517/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1517}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001518/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1518}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001519/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1519}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001520/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1520}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001521/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1521}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001522/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1522}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001523/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1523}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001524/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1524}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001525/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1525}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001526/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1526}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001527/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1527}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001528/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1528}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001529/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1529}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001530/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1530}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001531/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1531}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001532/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1532}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001533/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1533}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001534/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1534}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001535/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1535}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001536/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1536}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001537/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1537}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001538/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1538}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001539/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1539}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001540/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1540}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001541/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1541}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001542/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1542}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001543/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1543}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001544/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1544}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001545/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1545}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001546/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1546}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001547/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1547}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001548/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1548}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001549/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1549}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001550/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1550}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001551/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1551}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001552/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1552}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001553/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1553}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001554/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1554}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001555/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1555}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001556/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1556}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001557/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1557}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001558/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1558}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001559/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1559}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001560/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1560}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001561/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1561}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001562/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1562}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001563/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1563}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001564/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1564}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001565/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1565}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001566/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1566}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001567/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1567}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001568/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1568}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001569/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1569}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001570/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1570}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001571/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1571}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001572/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1572}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001573/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1573}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001574/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1574}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001575/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1575}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001576/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1576}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001577/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1577}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001578/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1578}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001579/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1579}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001580/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1580}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001581/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1581}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001582/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1582}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001583/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1583}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001584/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1584}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001585/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1585}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001586/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1586}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001587/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1587}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001588/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1588}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001589/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1589}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001590/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1590}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001591/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1591}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001592/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1592}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001593/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1593}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001594/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1594}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001595/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1595}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001596/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1596}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001597/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1597}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001598/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1598}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001599/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1599}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001600/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1600}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001601/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1601}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001602/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1602}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001603/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1603}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001604/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1604}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001605/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1605}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001606/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1606}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001607/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1607}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001608/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1608}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001609/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1609}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001610/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1610}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001611/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1611}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001612/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1612}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001613/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1613}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001614/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1614}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001615/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1615}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001616/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1616}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001617/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1617}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001618/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1618}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001619/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1619}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001620/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1620}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001621/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1621}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001622/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1622}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001623/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1623}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001624/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1624}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001625/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1625}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001626/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1626}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001627/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1627}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001628/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1628}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001629/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1629}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001630/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1630}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001631/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1631}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001632/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1632}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001633/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1633}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001634/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1634}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001635/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1635}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001636/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1636}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001637/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1637}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001638/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1638}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001639/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1639}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001640/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1640}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001641/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1641}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001642/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1642}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001643/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1643}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001644/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1644}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001645/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1645}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001646/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1646}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001647/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1647}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001648/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1648}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001649/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1649}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001650/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1650}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001651/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1651}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001652/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1652}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001653/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1653}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001654/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1654}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001655/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1655}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001656/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1656}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001657/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1657}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001658/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1658}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001659/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1659}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001660/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1660}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001661/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1661}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001662/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1662}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001663/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1663}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001664/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1664}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001665/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1665}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001666/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1666}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001667/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1667}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001668/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1668}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001669/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1669}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001670/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1670}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001671/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1671}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001672/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1672}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001673/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1673}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001674/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1674}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001675/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1675}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001676/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1676}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001677/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1677}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001678/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1678}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001679/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1679}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001680/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1680}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001681/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1681}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001682/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1682}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001683/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1683}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001684/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1684}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001685/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1685}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001686/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1686}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001687/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1687}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001688/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1688}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001689/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1689}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001690/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1690}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001691/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1691}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001692/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1692}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001693/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1693}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001694/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1694}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001695/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1695}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001696/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1696}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001697/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1697}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001698/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1698}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001699/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1699}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001700/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1700}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001701/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1701}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001702/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1702}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001703/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1703}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001704/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1704}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001705/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1705}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001706/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1706}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001707/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1707}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001708/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1708}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001709/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1709}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001710/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1710}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001711/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1711}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001712/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1712}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001713/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1713}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001714/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1714}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001715/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1715}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001716/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1716}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001717/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1717}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001718/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1718}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001719/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1719}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001720/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1720}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001721/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1721}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001722/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1722}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001723/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1723}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001724/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1724}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001725/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1725}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001726/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1726}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001727/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1727}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001728/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1728}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001729/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1729}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001730/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1730}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001731/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1731}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001732/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1732}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001733/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1733}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001734/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1734}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001735/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1735}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001736/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1736}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001737/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1737}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001738/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1738}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001739/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1739}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001740/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1740}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001741/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1741}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001742/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1742}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001743/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1743}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001744/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1744}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001745/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1745}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001746/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1746}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001747/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1747}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001748/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1748}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001749/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1749}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001750/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1750}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001751/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1751}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001752/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1752}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001753/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1753}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001754/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1754}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001755/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1755}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001756/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1756}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001757/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1757}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001758/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1758}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001759/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1759}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001760/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1760}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001761/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1761}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001762/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1762}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001763/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1763}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001764/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1764}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001765/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1765}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001766/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1766}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001767/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1767}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001768/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1768}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001769/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1769}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001770/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1770}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001771/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1771}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001772/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1772}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001773/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1773}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001774/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1774}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001775/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1775}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001776/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1776}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001777/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1777}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001778/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1778}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001779/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1779}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001780/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1780}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001781/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1781}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001782/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1782}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001783/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1783}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001784/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1784}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001785/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1785}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001786/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1786}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001787/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1787}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001788/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1788}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001789/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1789}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001790/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1790}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001791/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1791}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001792/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1792}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001793/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1793}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001794/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1794}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001795/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1795}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001796/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1796}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001797/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1797}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001798/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1798}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001799/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1799}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001800/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1800}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001801/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1801}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001802/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1802}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001803/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1803}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001804/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1804}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001805/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1805}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001806/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1806}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001807/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1807}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001808/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1808}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001809/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1809}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001810/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1810}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001811/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1811}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001812/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1812}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001813/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1813}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001814/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1814}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001815/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1815}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001816/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1816}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001817/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1817}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001818/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1818}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001819/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1819}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001820/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1820}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001821/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1821}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001822/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1822}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001823/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1823}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001824/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1824}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001825/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1825}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001826/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1826}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001827/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1827}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001828/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1828}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001829/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1829}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001830/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1830}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001831/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1831}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001832/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1832}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001833/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1833}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001834/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1834}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001835/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1835}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001836/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1836}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001837/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1837}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001838/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1838}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001839/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1839}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001840/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1840}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001841/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1841}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001842/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1842}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001843/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1843}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001844/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1844}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001845/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1845}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001846/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1846}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001847/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1847}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001848/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1848}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001849/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1849}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001850/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1850}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001851/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1851}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001852/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1852}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001853/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1853}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001854/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1854}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001855/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1855}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001856/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1856}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001857/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1857}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001858/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1858}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001859/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1859}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001860/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1860}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001861/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1861}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001862/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1862}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001863/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1863}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001864/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1864}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001865/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1865}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001866/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1866}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001867/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1867}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001868/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1868}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001869/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1869}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001870/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1870}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001871/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1871}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001872/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1872}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001873/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1873}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001874/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1874}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001875/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1875}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001876/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1876}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001877/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1877}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001878/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1878}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001879/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1879}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001880/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1880}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001881/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1881}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001882/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1882}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001883/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1883}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001884/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1884}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001885/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1885}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001886/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1886}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001887/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1887}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001888/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1888}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001889/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1889}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001890/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1890}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001891/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1891}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001892/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1892}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001893/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1893}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001894/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1894}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001895/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1895}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001896/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1896}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001897/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1897}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001898/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1898}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001899/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1899}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001900/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1900}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001901/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1901}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001902/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1902}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001903/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1903}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001904/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1904}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001905/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1905}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001906/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1906}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001907/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1907}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001908/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1908}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001909/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1909}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001910/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1910}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001911/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1911}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001912/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1912}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001913/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1913}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001914/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1914}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001915/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1915}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001916/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1916}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001917/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1917}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001918/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1918}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001919/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1919}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001920/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1920}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001921/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1921}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001922/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1922}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001923/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1923}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001924/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1924}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001925/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1925}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001926/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1926}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001927/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1927}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001928/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1928}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001929/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1929}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001930/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1930}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001931/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1931}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001932/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1932}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001933/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1933}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001934/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1934}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001935/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1935}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001936/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1936}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001937/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1937}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001938/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1938}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001939/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1939}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001940/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1940}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001941/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1941}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001942/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1942}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001943/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1943}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001944/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1944}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001945/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1945}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001946/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1946}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001947/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1947}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001948/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1948}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001949/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1949}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001950/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1950}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001951/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1951}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001952/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1952}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001953/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1953}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001954/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1954}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001955/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1955}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001956/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1956}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001957/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1957}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001958/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1958}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001959/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1959}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001960/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1960}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001961/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1961}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001962/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1962}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001963/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1963}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001964/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1964}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001965/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1965}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001966/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1966}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001967/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1967}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001968/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1968}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001969/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1969}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001970/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1970}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001971/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1971}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001972/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1972}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001973/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1973}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001974/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1974}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001975/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1975}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001976/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1976}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001977/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1977}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001978/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1978}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001979/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1979}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001980/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1980}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001981/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1981}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001982/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1982}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001983/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1983}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001984/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1984}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001985/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1985}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001986/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1986}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001987/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1987}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001988/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1988}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001989/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1989}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001990/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1990}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001991/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1991}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001992/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1992}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001993/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1993}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001994/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1994}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001995/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1995}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001996/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1996}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001997/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 1997}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001998/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1998}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00001999/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 1999}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002000/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2000}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002001/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2001}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002002/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2002}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002003/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2003}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002004/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2004}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002005/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2005}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002006/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2006}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002007/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2007}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002008/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2008}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002009/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2009}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002010/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2010}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002011/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2011}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002012/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2012}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002013/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2013}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002014/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2014}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002015/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2015}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002016/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2016}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002017/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2017}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002018/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2018}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002019/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2019}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002020/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2020}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002021/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2021}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002022/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2022}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002023/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2023}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002024/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2024}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002025/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2025}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002026/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2026}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002027/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2027}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002028/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2028}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002029/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2029}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002030/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2030}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002031/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2031}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002032/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2032}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002033/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2033}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002034/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2034}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002035/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2035}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002036/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2036}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002037/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2037}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002038/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2038}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002039/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2039}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002040/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2040}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002041/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2041}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002042/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2042}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002043/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2043}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002044/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2044}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002045/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2045}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002046/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2046}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002047/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2047}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002048/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2048}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002049/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2049}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002050/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2050}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002051/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2051}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002052/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2052}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002053/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2053}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002054/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2054}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002055/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2055}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002056/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2056}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002057/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2057}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002058/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2058}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002059/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2059}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002060/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2060}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002061/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2061}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002062/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2062}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002063/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2063}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002064/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2064}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002065/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2065}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002066/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2066}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002067/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2067}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002068/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2068}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002069/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2069}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002070/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2070}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002071/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2071}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002072/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2072}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002073/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2073}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002074/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2074}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002075/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2075}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002076/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2076}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002077/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2077}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002078/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2078}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002079/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2079}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002080/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2080}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002081/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2081}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002082/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2082}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002083/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2083}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002084/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2084}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002085/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2085}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002086/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2086}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002087/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2087}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002088/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2088}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002089/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2089}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002090/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2090}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002091/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2091}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002092/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2092}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002093/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2093}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002094/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2094}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002095/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2095}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002096/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2096}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002097/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2097}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002098/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2098}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002099/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2099}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002100/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2100}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002101/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2101}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002102/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2102}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002103/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2103}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002104/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2104}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002105/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2105}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002106/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2106}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002107/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2107}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002108/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2108}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002109/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2109}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002110/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2110}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002111/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2111}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002112/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2112}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002113/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2113}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002114/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2114}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002115/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2115}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002116/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2116}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002117/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2117}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002118/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2118}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002119/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2119}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002120/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2120}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002121/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2121}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002122/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2122}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002123/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2123}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002124/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2124}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002125/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2125}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002126/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2126}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002127/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2127}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002128/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2128}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002129/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2129}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002130/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2130}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002131/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2131}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002132/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2132}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002133/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2133}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002134/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2134}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002135/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2135}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002136/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2136}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002137/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2137}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002138/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2138}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002139/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2139}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002140/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2140}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002141/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2141}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002142/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2142}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002143/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2143}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002144/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2144}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002145/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2145}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002146/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2146}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002147/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2147}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002148/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2148}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002149/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2149}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002150/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2150}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002151/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2151}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002152/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2152}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002153/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2153}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002154/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2154}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002155/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2155}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002156/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2156}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002157/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2157}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002158/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2158}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002159/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2159}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002160/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2160}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002161/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2161}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002162/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2162}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002163/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2163}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002164/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2164}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002165/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2165}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002166/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2166}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002167/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2167}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002168/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2168}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002169/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2169}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002170/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2170}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002171/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2171}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002172/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2172}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002173/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2173}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002174/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2174}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002175/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2175}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002176/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2176}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002177/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2177}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002178/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2178}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002179/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2179}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002180/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2180}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002181/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2181}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002182/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2182}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002183/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2183}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002184/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2184}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002185/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2185}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002186/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2186}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002187/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2187}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002188/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2188}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002189/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2189}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002190/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2190}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002191/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2191}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002192/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2192}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002193/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2193}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002194/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2194}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002195/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2195}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002196/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2196}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002197/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2197}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002198/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2198}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002199/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2199}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002200/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2200}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002201/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2201}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002202/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2202}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002203/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2203}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002204/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2204}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002205/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2205}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002206/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2206}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002207/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2207}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002208/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2208}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002209/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2209}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002210/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2210}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002211/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2211}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002212/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2212}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002213/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2213}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002214/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2214}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002215/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2215}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002216/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2216}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002217/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2217}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002218/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2218}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002219/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2219}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002220/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2220}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002221/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2221}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002222/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2222}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002223/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2223}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002224/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2224}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002225/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2225}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002226/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2226}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002227/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2227}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002228/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2228}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002229/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2229}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002230/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2230}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002231/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2231}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002232/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2232}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002233/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2233}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002234/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2234}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002235/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2235}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002236/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2236}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002237/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2237}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002238/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2238}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002239/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2239}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002240/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2240}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002241/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2241}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002242/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2242}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002243/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2243}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002244/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2244}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002245/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2245}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002246/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2246}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002247/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2247}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002248/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2248}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002249/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2249}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002250/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2250}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002251/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2251}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002252/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2252}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002253/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2253}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002254/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2254}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002255/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2255}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002256/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2256}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002257/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2257}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002258/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2258}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002259/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2259}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002260/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2260}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002261/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2261}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002262/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2262}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002263/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2263}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002264/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2264}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002265/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2265}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002266/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2266}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002267/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2267}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002268/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2268}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002269/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2269}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002270/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2270}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002271/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2271}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002272/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2272}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002273/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2273}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002274/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2274}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002275/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2275}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002276/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2276}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002277/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2277}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002278/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2278}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002279/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2279}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002280/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2280}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002281/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2281}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002282/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2282}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002283/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2283}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002284/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2284}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002285/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2285}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002286/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2286}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002287/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2287}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002288/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2288}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002289/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2289}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002290/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2290}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002291/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2291}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002292/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2292}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002293/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2293}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002294/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2294}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002295/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2295}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002296/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2296}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002297/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2297}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002298/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2298}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002299/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2299}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002300/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2300}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002301/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2301}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002302/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2302}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002303/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2303}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002304/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2304}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002305/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2305}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002306/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2306}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002307/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2307}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002308/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2308}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002309/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2309}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002310/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2310}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002311/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2311}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002312/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2312}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002313/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2313}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002314/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2314}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002315/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2315}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002316/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2316}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002317/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2317}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002318/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2318}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002319/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2319}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002320/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2320}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002321/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2321}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002322/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2322}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002323/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2323}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002324/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2324}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002325/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2325}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002326/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2326}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002327/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2327}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002328/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2328}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002329/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2329}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002330/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2330}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002331/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2331}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002332/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2332}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002333/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2333}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002334/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2334}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002335/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2335}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002336/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2336}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002337/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2337}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002338/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2338}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002339/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2339}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002340/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2340}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002341/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2341}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002342/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2342}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002343/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2343}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002344/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2344}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002345/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2345}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002346/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2346}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002347/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2347}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002348/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2348}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002349/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2349}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002350/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2350}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002351/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2351}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002352/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2352}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002353/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2353}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002354/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2354}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002355/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2355}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002356/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2356}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002357/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2357}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002358/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2358}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002359/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2359}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002360/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2360}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002361/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2361}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002362/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2362}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002363/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2363}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002364/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2364}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002365/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2365}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002366/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2366}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002367/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2367}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002368/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2368}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002369/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2369}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002370/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2370}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002371/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2371}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002372/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2372}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002373/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2373}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002374/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2374}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002375/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2375}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002376/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2376}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002377/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2377}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002378/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2378}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002379/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2379}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002380/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2380}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002381/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2381}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002382/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2382}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002383/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2383}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002384/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2384}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002385/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2385}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002386/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2386}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002387/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2387}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002388/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2388}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002389/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2389}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002390/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2390}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002391/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2391}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002392/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2392}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002393/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2393}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002394/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2394}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002395/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2395}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002396/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2396}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002397/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2397}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002398/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2398}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002399/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2399}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002400/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2400}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002401/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2401}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002402/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2402}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002403/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2403}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002404/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2404}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002405/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2405}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002406/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2406}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002407/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2407}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002408/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2408}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002409/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2409}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002410/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2410}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002411/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2411}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002412/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2412}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002413/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2413}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002414/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2414}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002415/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2415}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002416/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2416}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002417/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2417}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002418/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2418}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002419/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2419}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002420/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2420}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002421/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2421}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002422/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2422}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002423/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2423}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002424/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2424}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002425/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2425}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002426/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2426}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002427/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2427}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002428/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2428}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002429/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2429}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002430/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2430}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002431/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2431}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002432/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2432}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002433/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2433}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002434/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2434}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002435/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2435}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002436/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2436}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002437/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2437}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002438/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2438}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002439/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2439}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002440/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2440}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002441/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2441}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002442/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2442}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002443/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2443}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002444/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2444}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002445/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2445}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002446/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2446}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002447/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2447}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002448/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2448}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002449/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2449}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002450/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2450}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002451/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2451}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002452/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2452}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002453/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2453}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002454/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2454}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002455/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2455}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002456/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2456}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002457/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2457}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002458/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2458}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002459/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2459}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002460/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2460}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002461/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2461}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002462/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2462}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002463/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2463}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002464/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2464}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002465/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2465}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002466/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2466}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002467/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2467}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002468/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2468}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002469/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2469}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002470/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2470}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002471/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2471}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002472/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2472}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002473/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2473}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002474/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2474}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002475/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2475}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002476/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2476}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002477/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2477}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002478/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2478}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002479/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2479}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002480/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2480}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002481/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2481}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002482/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2482}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002483/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2483}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002484/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2484}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002485/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2485}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002486/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2486}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002487/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2487}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002488/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2488}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002489/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2489}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002490/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2490}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002491/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2491}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002492/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2492}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002493/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2493}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002494/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2494}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002495/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2495}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002496/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2496}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002497/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2497}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002498/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2498}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002499/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2499}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002500/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2500}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002501/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2501}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002502/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2502}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002503/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2503}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002504/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2504}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002505/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2505}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002506/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2506}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002507/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2507}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002508/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2508}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002509/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2509}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002510/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2510}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002511/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2511}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002512/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2512}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002513/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2513}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002514/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2514}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002515/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2515}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002516/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2516}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002517/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2517}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002518/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2518}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002519/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2519}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002520/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2520}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002521/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2521}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002522/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2522}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002523/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2523}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002524/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2524}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002525/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2525}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002526/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2526}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002527/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2527}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002528/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2528}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002529/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2529}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002530/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2530}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002531/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2531}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002532/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2532}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002533/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2533}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002534/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2534}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002535/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2535}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002536/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2536}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002537/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2537}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002538/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2538}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002539/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2539}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002540/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2540}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002541/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2541}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002542/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2542}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002543/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2543}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002544/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2544}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002545/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2545}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002546/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2546}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002547/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2547}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002548/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2548}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002549/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2549}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002550/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2550}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002551/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2551}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002552/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2552}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002553/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2553}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002554/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2554}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002555/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2555}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002556/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2556}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002557/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2557}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002558/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2558}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002559/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2559}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002560/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2560}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002561/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2561}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002562/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2562}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002563/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2563}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002564/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2564}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002565/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2565}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002566/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2566}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002567/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2567}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002568/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2568}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002569/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2569}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002570/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2570}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002571/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … ��� a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2571}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002572/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2572}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002573/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2573}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002574/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2574}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002575/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2575}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002576/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2576}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002577/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2577}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002578/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2578}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002579/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2579}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002580/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2580}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002581/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2581}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002582/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2582}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002583/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2583}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002584/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2584}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002585/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2585}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002586/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2586}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002587/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2587}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002588/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2588}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002589/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2589}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002590/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2590}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002591/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2591}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002592/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2592}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002593/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2593}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002594/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2594}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002595/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2595}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002596/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2596}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002597/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2597}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002598/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2598}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002599/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2599}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002600/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2600}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002601/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2601}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002602/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2602}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002603/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2603}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002604/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2604}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002605/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2605}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002606/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2606}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002607/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2607}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002608/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2608}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002609/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2609}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002610/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2610}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002611/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2611}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002612/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2612}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002613/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2613}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002614/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2614}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002615/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2615}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002616/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2616}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002617/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2617}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002618/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2618}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002619/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2619}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002620/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2620}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002621/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2621}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002622/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2622}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002623/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2623}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002624/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2624}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002625/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2625}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002626/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2626}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002627/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2627}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002628/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2628}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002629/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2629}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002630/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2630}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002631/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2631}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002632/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2632}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002633/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2633}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002634/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2634}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002635/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2635}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002636/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2636}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002637/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2637}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002638/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2638}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002639/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2639}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002640/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2640}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002641/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2641}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002642/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2642}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002643/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2643}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002644/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2644}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002645/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2645}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002646/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2646}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002647/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2647}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002648/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2648}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002649/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2649}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002650/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2650}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002651/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2651}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002652/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2652}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002653/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2653}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002654/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2654}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002655/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2655}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002656/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2656}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002657/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2657}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002658/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2658}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002659/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2659}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002660/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2660}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002661/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2661}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002662/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2662}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002663/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2663}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002664/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2664}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002665/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2665}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002666/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2666}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002667/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2667}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002668/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2668}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002669/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2669}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002670/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2670}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002671/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2671}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002672/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2672}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002673/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2673}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002674/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2674}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002675/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2675}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002676/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2676}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002677/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2677}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002678/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2678}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002679/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2679}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002680/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2680}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002681/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2681}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002682/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2682}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002683/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2683}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002684/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2684}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002685/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2685}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002686/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2686}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002687/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2687}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002688/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2688}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002689/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2689}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002690/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2690}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002691/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2691}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002692/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2692}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002693/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2693}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002694/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2694}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002695/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2695}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002696/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2696}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002697/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2697}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002698/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2698}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002699/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2699}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002700/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2700}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002701/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2701}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002702/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2702}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002703/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2703}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002704/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2704}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002705/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2705}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002706/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2706}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002707/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2707}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002708/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2708}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002709/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2709}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002710/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2710}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002711/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2711}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002712/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2712}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002713/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2713}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002714/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2714}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002715/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2715}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002716/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2716}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002717/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2717}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002718/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2718}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002719/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2719}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002720/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2720}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002721/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2721}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002722/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2722}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002723/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2723}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002724/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2724}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002725/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2725}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002726/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2726}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002727/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2727}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002728/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2728}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002729/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2729}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002730/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2730}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002731/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2731}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002732/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2732}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002733/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2733}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002734/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2734}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002735/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2735}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002736/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2736}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002737/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2737}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002738/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2738}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002739/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2739}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002740/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2740}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002741/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2741}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002742/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2742}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002743/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2743}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002744/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2744}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002745/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2745}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002746/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2746}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002747/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2747}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002748/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2748}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002749/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2749}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002750/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2750}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002751/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2751}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002752/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2752}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002753/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2753}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002754/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2754}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002755/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2755}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002756/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2756}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002757/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2757}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002758/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2758}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002759/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2759}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002760/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2760}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002761/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2761}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002762/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2762}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002763/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2763}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002764/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2764}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002765/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2765}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002766/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2766}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002767/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2767}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002768/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2768}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002769/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2769}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002770/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2770}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002771/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2771}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002772/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2772}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002773/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2773}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002774/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2774}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002775/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2775}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002776/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2776}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002777/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2777}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002778/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2778}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002779/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2779}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002780/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2780}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002781/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2781}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002782/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2782}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002783/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2783}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002784/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2784}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002785/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2785}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002786/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2786}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002787/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2787}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002788/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2788}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002789/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2789}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002790/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2790}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002791/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2791}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002792/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2792}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002793/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2793}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002794/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2794}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002795/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2795}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002796/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2796}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002797/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2797}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002798/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2798}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002799/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2799}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002800/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2800}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002801/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2801}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002802/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2802}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002803/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2803}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002804/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2804}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002805/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2805}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002806/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2806}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002807/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2807}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002808/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2808}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002809/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2809}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002810/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2810}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002811/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2811}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002812/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2812}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002813/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2813}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002814/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2814}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002815/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2815}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002816/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2816}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002817/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2817}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002818/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2818}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002819/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2819}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002820/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2820}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002821/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2821}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002822/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2822}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002823/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2823}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002824/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2824}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002825/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2825}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002826/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2826}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002827/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2827}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002828/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2828}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002829/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2829}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002830/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2830}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002831/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2831}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002832/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2832}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002833/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2833}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002834/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2834}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002835/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2835}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002836/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2836}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002837/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2837}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002838/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2838}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002839/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2839}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002840/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2840}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002841/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2841}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002842/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2842}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002843/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2843}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002844/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2844}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002845/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2845}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002846/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2846}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002847/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2847}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002848/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2848}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002849/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2849}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002850/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2850}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002851/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2851}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002852/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2852}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002853/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2853}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002854/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2854}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002855/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2855}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002856/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2856}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002857/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2857}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002858/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2858}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002859/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2859}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002860/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2860}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002861/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2861}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002862/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2862}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002863/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2863}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002864/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2864}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002865/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2865}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002866/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2866}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002867/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2867}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002868/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2868}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002869/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2869}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002870/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2870}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002871/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2871}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002872/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2872}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002873/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2873}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002874/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2874}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002875/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2875}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002876/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2876}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002877/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2877}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002878/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2878}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002879/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2879}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002880/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2880}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002881/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2881}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002882/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2882}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002883/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2883}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002884/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2884}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002885/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2885}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002886/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2886}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002887/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2887}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002888/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2888}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002889/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2889}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002890/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2890}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002891/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2891}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002892/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2892}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002893/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2893}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002894/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2894}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002895/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2895}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002896/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2896}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002897/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2897}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002898/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2898}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002899/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2899}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002900/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2900}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002901/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2901}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002902/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2902}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002903/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2903}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002904/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2904}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002905/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2905}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002906/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2906}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002907/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2907}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002908/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2908}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002909/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2909}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002910/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2910}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002911/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2911}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002912/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2912}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002913/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2913}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002914/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2914}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002915/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2915}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002916/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2916}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002917/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2917}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002918/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2918}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002919/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2919}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002920/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2920}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002921/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2921}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002922/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2922}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002923/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2923}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002924/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2924}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002925/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2925}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002926/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2926}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002927/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2927}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002928/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2928}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002929/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2929}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002930/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2930}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002931/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2931}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002932/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2932}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002933/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2933}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002934/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2934}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002935/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2935}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002936/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2936}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002937/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2937}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002938/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2938}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002939/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2939}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002940/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2940}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002941/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2941}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002942/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2942}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002943/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2943}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002944/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2944}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002945/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2945}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002946/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2946}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002947/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2947}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002948/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2948}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002949/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2949}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002950/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2950}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002951/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2951}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002952/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2952}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002953/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2953}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002954/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2954}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002955/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2955}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002956/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2956}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002957/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2957}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002958/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2958}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002959/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2959}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002960/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2960}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002961/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2961}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002962/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2962}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002963/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2963}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002964/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2964}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002965/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2965}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002966/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2966}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002967/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2967}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002968/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2968}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002969/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2969}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002970/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2970}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002971/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2971}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002972/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2972}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002973/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2973}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002974/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2974}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002975/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2975}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002976/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2976}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002977/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2977}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002978/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2978}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002979/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2979}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002980/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2980}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002981/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2981}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002982/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2982}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002983/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2983}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002984/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2984}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002985/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2985}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002986/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2986}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002987/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2987}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002988/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2988}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002989/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2989}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002990/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2990}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002991/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2991}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002992/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2992}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002993/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2993}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002994/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2994}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002995/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2995}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002996/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2996}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002997/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2997}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002998/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 2998}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00002999/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 2999}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003000/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3000}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003001/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3001}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003002/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3002}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003003/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3003}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003004/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3004}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003005/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3005}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003006/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3006}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003007/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3007}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003008/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3008}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003009/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3009}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003010/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3010}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003011/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3011}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003012/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3012}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003013/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3013}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003014/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3014}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003015/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3015}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003016/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3016}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003017/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3017}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003018/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3018}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003019/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3019}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003020/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3020}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003021/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3021}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003022/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3022}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003023/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3023}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003024/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3024}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003025/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3025}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003026/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3026}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003027/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3027}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003028/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3028}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003029/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3029}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003030/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3030}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003031/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3031}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003032/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3032}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003033/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3033}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003034/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3034}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003035/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3035}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003036/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3036}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003037/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3037}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003038/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3038}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003039/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3039}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003040/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3040}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003041/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3041}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003042/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3042}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003043/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3043}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003044/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3044}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003045/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3045}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003046/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3046}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003047/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3047}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003048/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3048}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003049/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3049}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003050/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3050}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003051/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3051}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003052/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3052}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003053/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3053}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003054/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3054}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003055/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3055}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003056/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3056}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003057/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3057}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003058/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3058}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003059/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3059}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003060/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3060}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003061/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3061}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003062/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3062}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003063/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3063}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003064/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3064}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003065/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3065}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003066/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3066}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003067/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3067}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003068/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3068}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003069/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3069}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003070/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3070}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003071/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3071}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003072/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3072}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003073/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3073}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003074/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3074}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003075/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3075}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003076/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3076}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003077/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3077}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003078/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3078}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003079/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3079}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003080/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3080}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003081/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3081}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003082/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3082}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003083/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3083}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003084/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3084}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003085/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3085}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003086/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3086}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003087/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3087}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003088/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3088}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003089/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3089}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003090/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3090}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003091/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3091}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003092/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3092}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003093/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3093}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003094/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3094}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003095/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3095}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003096/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3096}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003097/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3097}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003098/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3098}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003099/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3099}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003100/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3100}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003101/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3101}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003102/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3102}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003103/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3103}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003104/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3104}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003105/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3105}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003106/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3106}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003107/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3107}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003108/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3108}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003109/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3109}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003110/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3110}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003111/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3111}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003112/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3112}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003113/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3113}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003114/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3114}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003115/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3115}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003116/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3116}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003117/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3117}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003118/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3118}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003119/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3119}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003120/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3120}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003121/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3121}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003122/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3122}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003123/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3123}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003124/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3124}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003125/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3125}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003126/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3126}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003127/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3127}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003128/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3128}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003129/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3129}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003130/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3130}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003131/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3131}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003132/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3132}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003133/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3133}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003134/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3134}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003135/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3135}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003136/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3136}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003137/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3137}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003138/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3138}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003139/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3139}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003140/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3140}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003141/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3141}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003142/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3142}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003143/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3143}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003144/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3144}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003145/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3145}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003146/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3146}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003147/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3147}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003148/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3148}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003149/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3149}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003150/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3150}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003151/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3151}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003152/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3152}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003153/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3153}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003154/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3154}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003155/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3155}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003156/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3156}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003157/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3157}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003158/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3158}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003159/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3159}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003160/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3160}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003161/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3161}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003162/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3162}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003163/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3163}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003164/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3164}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003165/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3165}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003166/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3166}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003167/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3167}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003168/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3168}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003169/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3169}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003170/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3170}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003171/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3171}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003172/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3172}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003173/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3173}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003174/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3174}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003175/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3175}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003176/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3176}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003177/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3177}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003178/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3178}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003179/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3179}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003180/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3180}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003181/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3181}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003182/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3182}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003183/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3183}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003184/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3184}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003185/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3185}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003186/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3186}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003187/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3187}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003188/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3188}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003189/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3189}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003190/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3190}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003191/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3191}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003192/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3192}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003193/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3193}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003194/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3194}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003195/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3195}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003196/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3196}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003197/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3197}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003198/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3198}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003199/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3199}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003200/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3200}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003201/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3201}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003202/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3202}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003203/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3203}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003204/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3204}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003205/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3205}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003206/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3206}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003207/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3207}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003208/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3208}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003209/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3209}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003210/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3210}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003211/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3211}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003212/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3212}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003213/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3213}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003214/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3214}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003215/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3215}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003216/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3216}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003217/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3217}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003218/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3218}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003219/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3219}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003220/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3220}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003221/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3221}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003222/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3222}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003223/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3223}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003224/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3224}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003225/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3225}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003226/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3226}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003227/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3227}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003228/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3228}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003229/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3229}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003230/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3230}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003231/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3231}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003232/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3232}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003233/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3233}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003234/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3234}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003235/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3235}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003236/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3236}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003237/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3237}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003238/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3238}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003239/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3239}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003240/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3240}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003241/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3241}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003242/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3242}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003243/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3243}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003244/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3244}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003245/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3245}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003246/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3246}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003247/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3247}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003248/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3248}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003249/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3249}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003250/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3250}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003251/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3251}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003252/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3252}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003253/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3253}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003254/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3254}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003255/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3255}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003256/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3256}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003257/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3257}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003258/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3258}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003259/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3259}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003260/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3260}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003261/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3261}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003262/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3262}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003263/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3263}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003264/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3264}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003265/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3265}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003266/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3266}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003267/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3267}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003268/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3268}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003269/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3269}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003270/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3270}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003271/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3271}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003272/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3272}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003273/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3273}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003274/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3274}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003275/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3275}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003276/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3276}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003277/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3277}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003278/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3278}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003279/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3279}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003280/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3280}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003281/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3281}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003282/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3282}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003283/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3283}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003284/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3284}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003285/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3285}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003286/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3286}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003287/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3287}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003288/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3288}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003289/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3289}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003290/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3290}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003291/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3291}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003292/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3292}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003293/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3293}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003294/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3294}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003295/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3295}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003296/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3296}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003297/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3297}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003298/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3298}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003299/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3299}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003300/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3300}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003301/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3301}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003302/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3302}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003303/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3303}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003304/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3304}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003305/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3305}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003306/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3306}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003307/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3307}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003308/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3308}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003309/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3309}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003310/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3310}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003311/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3311}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003312/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3312}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003313/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3313}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003314/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3314}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003315/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3315}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003316/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3316}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003317/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3317}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003318/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3318}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003319/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3319}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003320/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3320}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003321/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3321}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003322/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3322}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003323/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3323}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003324/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3324}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003325/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3325}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003326/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3326}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003327/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3327}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003328/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3328}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003329/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3329}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003330/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3330}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003331/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3331}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003332/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3332}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003333/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3333}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003334/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3334}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003335/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3335}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003336/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3336}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003337/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3337}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003338/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3338}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003339/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3339}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003340/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3340}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003341/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3341}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003342/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3342}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003343/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3343}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003344/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3344}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003345/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3345}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003346/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3346}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003347/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3347}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003348/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3348}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003349/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3349}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003350/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3350}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003351/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3351}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003352/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3352}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003353/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3353}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003354/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3354}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003355/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3355}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003356/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3356}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003357/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3357}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003358/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3358}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003359/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3359}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003360/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3360}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003361/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3361}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003362/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3362}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003363/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3363}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003364/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3364}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003365/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3365}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003366/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3366}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003367/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3367}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003368/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3368}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003369/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3369}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003370/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3370}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003371/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3371}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003372/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3372}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003373/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3373}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003374/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3374}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003375/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3375}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003376/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3376}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003377/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3377}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003378/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3378}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003379/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3379}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003380/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3380}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003381/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3381}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003382/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3382}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003383/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3383}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003384/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3384}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003385/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3385}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003386/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3386}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003387/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3387}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003388/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3388}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003389/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3389}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003390/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3390}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003391/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3391}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003392/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3392}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003393/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3393}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003394/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3394}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003395/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3395}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003396/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3396}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003397/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3397}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003398/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3398}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003399/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3399}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003400/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3400}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003401/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3401}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003402/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3402}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003403/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3403}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003404/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3404}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003405/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3405}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003406/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3406}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003407/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3407}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003408/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3408}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003409/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3409}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003410/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3410}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003411/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3411}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003412/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3412}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003413/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3413}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003414/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3414}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003415/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3415}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003416/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3416}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003417/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3417}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003418/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3418}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003419/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3419}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003420/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3420}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003421/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3421}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003422/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3422}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003423/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3423}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003424/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3424}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003425/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3425}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003426/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3426}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003427/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3427}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003428/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3428}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003429/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3429}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003430/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3430}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003431/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3431}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003432/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3432}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003433/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3433}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003434/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3434}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003435/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3435}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003436/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3436}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003437/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3437}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003438/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3438}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003439/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3439}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003440/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3440}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003441/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3441}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003442/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3442}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003443/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3443}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003444/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3444}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003445/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3445}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003446/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3446}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003447/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3447}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003448/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3448}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003449/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3449}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003450/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3450}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003451/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3451}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003452/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3452}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003453/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3453}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003454/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3454}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003455/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3455}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003456/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3456}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003457/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3457}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003458/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3458}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003459/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3459}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003460/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3460}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003461/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3461}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003462/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3462}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003463/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3463}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003464/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3464}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003465/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3465}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003466/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3466}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003467/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3467}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003468/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3468}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003469/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3469}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003470/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3470}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003471/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3471}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003472/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3472}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003473/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3473}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003474/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3474}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003475/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3475}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003476/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3476}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003477/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3477}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003478/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3478}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003479/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3479}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003480/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3480}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003481/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3481}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003482/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3482}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003483/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3483}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003484/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3484}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003485/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3485}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003486/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3486}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003487/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3487}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003488/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3488}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003489/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3489}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003490/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3490}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003491/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3491}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003492/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3492}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003493/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3493}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003494/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3494}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003495/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3495}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003496/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3496}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003497/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3497}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003498/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3498}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003499/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3499}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003500/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3500}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003501/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3501}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003502/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3502}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003503/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3503}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003504/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3504}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003505/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3505}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003506/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3506}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003507/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3507}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003508/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3508}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003509/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3509}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003510/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3510}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003511/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3511}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003512/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3512}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003513/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3513}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003514/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3514}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003515/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3515}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003516/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3516}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003517/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3517}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003518/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3518}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003519/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3519}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003520/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3520}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003521/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3521}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003522/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3522}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003523/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3523}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003524/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3524}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003525/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3525}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003526/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3526}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003527/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3527}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003528/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3528}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003529/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3529}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003530/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3530}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003531/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3531}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003532/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3532}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003533/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3533}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003534/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3534}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003535/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3535}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003536/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3536}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003537/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3537}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003538/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3538}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003539/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3539}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003540/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3540}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003541/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3541}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003542/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3542}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003543/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3543}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003544/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3544}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003545/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3545}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003546/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3546}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003547/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3547}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003548/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3548}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003549/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3549}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003550/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3550}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003551/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3551}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003552/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3552}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003553/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3553}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003554/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3554}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003555/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3555}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003556/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3556}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003557/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3557}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003558/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3558}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003559/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3559}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003560/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3560}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003561/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3561}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003562/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3562}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003563/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3563}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003564/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3564}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003565/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3565}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003566/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3566}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003567/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3567}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003568/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3568}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003569/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3569}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003570/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3570}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003571/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3571}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003572/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3572}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003573/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3573}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003574/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3574}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003575/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3575}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003576/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3576}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003577/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3577}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003578/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3578}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003579/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3579}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003580/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3580}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003581/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3581}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003582/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3582}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003583/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3583}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003584/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3584}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003585/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3585}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003586/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3586}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003587/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3587}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003588/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3588}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003589/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3589}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003590/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3590}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003591/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3591}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003592/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3592}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003593/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3593}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003594/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3594}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003595/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3595}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003596/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3596}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003597/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3597}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003598/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3598}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003599/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3599}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003600/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3600}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003601/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3601}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003602/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3602}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003603/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3603}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003604/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3604}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003605/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3605}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003606/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3606}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003607/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3607}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003608/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3608}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003609/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3609}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003610/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3610}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003611/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3611}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003612/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3612}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003613/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3613}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003614/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3614}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003615/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3615}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003616/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3616}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003617/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3617}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003618/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3618}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003619/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3619}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003620/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3620}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003621/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3621}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003622/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3622}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003623/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3623}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003624/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3624}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003625/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3625}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003626/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3626}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003627/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3627}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003628/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3628}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003629/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3629}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003630/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3630}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003631/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3631}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003632/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3632}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003633/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3633}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003634/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3634}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003635/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3635}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003636/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3636}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003637/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3637}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003638/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3638}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003639/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3639}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003640/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3640}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003641/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3641}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003642/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3642}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003643/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3643}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003644/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3644}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003645/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3645}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003646/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3646}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003647/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3647}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003648/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3648}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003649/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3649}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003650/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3650}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003651/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3651}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003652/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3652}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003653/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3653}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003654/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3654}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003655/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3655}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003656/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3656}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003657/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3657}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003658/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3658}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003659/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3659}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003660/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3660}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003661/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3661}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003662/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3662}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003663/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3663}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003664/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3664}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003665/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3665}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003666/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3666}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003667/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3667}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003668/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3668}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003669/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3669}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003670/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3670}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003671/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3671}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003672/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3672}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003673/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3673}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003674/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3674}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003675/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3675}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003676/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3676}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003677/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3677}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003678/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3678}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003679/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3679}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003680/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3680}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003681/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3681}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003682/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3682}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003683/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3683}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003684/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3684}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003685/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3685}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003686/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3686}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003687/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3687}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003688/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3688}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003689/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3689}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003690/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3690}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003691/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3691}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003692/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3692}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003693/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3693}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003694/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3694}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003695/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3695}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003696/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3696}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003697/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3697}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003698/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3698}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003699/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3699}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003700/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3700}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003701/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3701}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003702/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3702}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003703/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3703}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003704/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3704}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003705/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3705}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003706/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3706}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003707/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3707}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003708/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3708}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003709/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3709}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003710/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3710}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003711/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3711}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003712/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3712}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003713/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3713}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003714/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3714}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003715/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3715}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003716/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3716}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003717/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3717}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003718/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3718}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003719/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3719}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003720/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3720}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003721/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3721}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003722/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3722}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003723/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3723}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003724/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3724}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003725/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3725}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003726/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3726}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003727/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3727}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003728/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3728}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003729/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3729}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003730/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3730}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003731/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3731}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003732/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3732}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003733/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3733}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003734/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3734}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003735/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3735}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003736/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3736}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003737/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3737}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003738/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3738}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003739/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3739}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003740/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3740}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003741/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3741}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003742/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3742}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003743/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3743}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003744/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3744}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003745/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3745}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003746/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3746}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003747/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3747}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003748/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3748}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003749/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3749}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003750/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3750}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003751/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3751}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003752/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3752}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003753/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3753}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003754/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3754}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003755/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3755}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003756/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3756}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003757/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3757}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003758/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3758}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003759/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3759}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003760/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3760}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003761/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3761}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003762/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3762}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003763/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3763}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003764/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3764}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003765/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3765}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003766/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3766}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003767/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3767}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003768/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3768}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003769/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3769}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003770/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3770}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003771/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3771}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003772/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3772}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003773/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3773}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003774/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3774}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003775/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3775}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003776/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3776}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003777/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3777}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003778/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3778}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003779/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3779}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003780/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3780}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003781/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3781}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003782/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3782}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003783/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3783}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003784/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3784}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003785/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3785}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003786/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3786}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003787/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3787}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003788/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3788}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003789/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3789}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003790/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3790}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003791/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3791}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003792/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3792}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003793/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3793}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003794/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3794}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003795/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3795}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003796/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3796}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003797/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3797}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003798/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3798}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003799/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3799}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003800/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3800}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003801/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3801}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003802/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3802}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003803/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3803}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003804/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3804}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003805/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3805}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003806/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3806}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003807/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3807}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003808/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3808}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003809/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3809}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003810/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3810}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003811/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3811}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003812/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3812}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003813/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3813}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003814/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3814}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003815/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3815}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003816/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3816}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003817/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3817}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003818/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3818}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003819/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3819}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003820/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3820}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003821/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3821}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003822/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3822}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003823/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3823}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003824/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3824}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003825/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3825}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003826/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3826}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003827/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3827}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003828/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3828}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003829/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3829}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003830/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3830}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003831/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3831}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003832/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3832}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003833/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3833}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003834/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3834}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003835/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3835}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003836/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3836}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003837/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3837}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003838/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3838}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003839/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3839}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003840/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3840}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003841/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3841}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003842/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3842}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003843/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3843}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003844/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3844}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003845/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3845}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003846/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3846}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003847/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3847}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003848/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3848}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003849/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3849}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003850/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3850}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003851/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3851}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003852/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3852}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003853/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3853}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003854/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3854}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003855/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3855}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003856/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3856}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003857/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3857}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003858/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3858}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003859/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3859}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003860/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3860}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003861/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3861}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003862/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3862}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003863/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3863}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003864/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3864}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003865/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3865}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003866/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3866}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003867/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3867}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003868/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3868}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003869/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3869}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003870/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3870}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003871/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3871}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003872/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3872}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003873/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3873}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003874/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3874}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003875/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3875}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003876/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3876}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003877/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3877}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003878/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3878}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003879/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3879}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003880/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3880}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003881/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3881}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003882/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3882}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003883/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3883}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003884/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3884}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003885/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3885}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003886/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3886}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003887/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3887}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003888/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3888}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003889/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3889}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003890/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3890}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003891/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3891}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003892/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3892}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003893/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3893}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003894/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3894}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003895/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3895}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003896/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3896}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003897/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3897}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003898/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3898}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003899/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3899}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003900/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3900}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003901/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3901}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003902/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3902}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003903/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3903}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003904/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3904}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003905/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3905}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003906/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3906}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003907/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3907}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003908/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3908}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003909/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3909}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003910/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3910}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003911/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3911}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003912/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3912}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003913/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3913}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003914/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3914}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003915/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3915}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003916/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3916}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003917/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3917}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003918/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3918}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003919/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3919}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003920/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3920}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003921/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3921}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003922/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3922}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003923/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3923}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003924/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3924}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003925/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3925}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003926/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3926}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003927/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3927}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003928/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3928}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003929/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3929}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003930/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3930}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003931/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3931}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003932/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3932}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003933/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3933}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003934/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3934}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003935/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3935}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003936/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3936}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003937/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3937}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003938/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3938}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003939/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3939}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003940/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3940}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003941/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3941}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003942/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3942}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003943/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3943}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003944/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3944}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003945/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3945}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003946/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3946}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003947/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3947}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003948/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3948}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003949/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3949}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003950/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3950}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003951/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3951}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003952/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3952}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003953/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3953}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003954/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3954}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003955/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3955}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003956/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3956}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003957/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3957}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003958/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3958}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003959/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3959}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003960/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3960}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003961/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3961}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003962/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3962}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003963/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3963}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003964/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3964}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003965/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3965}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003966/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3966}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003967/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3967}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003968/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3968}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003969/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3969}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003970/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3970}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003971/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3971}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003972/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3972}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003973/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3973}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003974/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3974}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003975/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3975}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003976/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3976}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003977/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3977}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003978/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3978}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003979/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3979}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003980/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3980}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003981/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3981}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003982/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3982}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003983/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3983}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003984/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3984}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003985/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3985}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003986/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3986}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003987/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3987}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003988/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3988}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003989/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3989}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003990/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3990}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003991/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3991}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003992/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3992}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003993/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3993}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003994/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3994}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003995/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 3995}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003996/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3996}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003997/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3997}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003998/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3998}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00003999/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 3999}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004000/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4000}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004001/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4001}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004002/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4002}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004003/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4003}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004004/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4004}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004005/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4005}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004006/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4006}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004007/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4007}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004008/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4008}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004009/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4009}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004010/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4010}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004011/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4011}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004012/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4012}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004013/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4013}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004014/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4014}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004015/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4015}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004016/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4016}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004017/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4017}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004018/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4018}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004019/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4019}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004020/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4020}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004021/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4021}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004022/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4022}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004023/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4023}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004024/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4024}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004025/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4025}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004026/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4026}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004027/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4027}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004028/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4028}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004029/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4029}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004030/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4030}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004031/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4031}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004032/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4032}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004033/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4033}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004034/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4034}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004035/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4035}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004036/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4036}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004037/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4037}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004038/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4038}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004039/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4039}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004040/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4040}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004041/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4041}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004042/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4042}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004043/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4043}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004044/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4044}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004045/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4045}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004046/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4046}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004047/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4047}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004048/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4048}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004049/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4049}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004050/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4050}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004051/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4051}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004052/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4052}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004053/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4053}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004054/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4054}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004055/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4055}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004056/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4056}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004057/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4057}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004058/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4058}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004059/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4059}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004060/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4060}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004061/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4061}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004062/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4062}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004063/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4063}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004064/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4064}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004065/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4065}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004066/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4066}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004067/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4067}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004068/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4068}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004069/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4069}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004070/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4070}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004071/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4071}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004072/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4072}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004073/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4073}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004074/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4074}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004075/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4075}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004076/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4076}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004077/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4077}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004078/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4078}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004079/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4079}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004080/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4080}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004081/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4081}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004082/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4082}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004083/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4083}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004084/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4084}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004085/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4085}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004086/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4086}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004087/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4087}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004088/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4088}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004089/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4089}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004090/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4090}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004091/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4091}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004092/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4092}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004093/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4093}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004094/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4094}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004095/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4095}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004096/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4096}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004097/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4097}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004098/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4098}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004099/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4099}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004100/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4100}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004101/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4101}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004102/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4102}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004103/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4103}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004104/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4104}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004105/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4105}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004106/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4106}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004107/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4107}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004108/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4108}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004109/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4109}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004110/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4110}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004111/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4111}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004112/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4112}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004113/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4113}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004114/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4114}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004115/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4115}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004116/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4116}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004117/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4117}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004118/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4118}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004119/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4119}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004120/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4120}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004121/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4121}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004122/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4122}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004123/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4123}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004124/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4124}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004125/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4125}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004126/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4126}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004127/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4127}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004128/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4128}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004129/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4129}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004130/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4130}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004131/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4131}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004132/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4132}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004133/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4133}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004134/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4134}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004135/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4135}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004136/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4136}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004137/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4137}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004138/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4138}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004139/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4139}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004140/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4140}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004141/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4141}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004142/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4142}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004143/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4143}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004144/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4144}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004145/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4145}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004146/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4146}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004147/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4147}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004148/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4148}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004149/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4149}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004150/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4150}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004151/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4151}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004152/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4152}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004153/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4153}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004154/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4154}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004155/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4155}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004156/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4156}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004157/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4157}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004158/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4158}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004159/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4159}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004160/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4160}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004161/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4161}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004162/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4162}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004163/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4163}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004164/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4164}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004165/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4165}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004166/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4166}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004167/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4167}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004168/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4168}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004169/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4169}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004170/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4170}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004171/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4171}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004172/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4172}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004173/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4173}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004174/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4174}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004175/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4175}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004176/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4176}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004177/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4177}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004178/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4178}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004179/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4179}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004180/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4180}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004181/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4181}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004182/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4182}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004183/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4183}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004184/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4184}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004185/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4185}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004186/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4186}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004187/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4187}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004188/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4188}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004189/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4189}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004190/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4190}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004191/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4191}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004192/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4192}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004193/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4193}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004194/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4194}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004195/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4195}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004196/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4196}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004197/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4197}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004198/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4198}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004199/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4199}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004200/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4200}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004201/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4201}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004202/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4202}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004203/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4203}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004204/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4204}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004205/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4205}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004206/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4206}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004207/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4207}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004208/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4208}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004209/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4209}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004210/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4210}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004211/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4211}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004212/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4212}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004213/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4213}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004214/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4214}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004215/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4215}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004216/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4216}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004217/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4217}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004218/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4218}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004219/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4219}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004220/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4220}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004221/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4221}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004222/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4222}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004223/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4223}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004224/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4224}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004225/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4225}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004226/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4226}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004227/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4227}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004228/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4228}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004229/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4229}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004230/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4230}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004231/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4231}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004232/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4232}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004233/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4233}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004234/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4234}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004235/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4235}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004236/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4236}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004237/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4237}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004238/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4238}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004239/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4239}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004240/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4240}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004241/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4241}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004242/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4242}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004243/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4243}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004244/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4244}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004245/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4245}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004246/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4246}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004247/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4247}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004248/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4248}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004249/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4249}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004250/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4250}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004251/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4251}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004252/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4252}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004253/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4253}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004254/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4254}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004255/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4255}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004256/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4256}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004257/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4257}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004258/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4258}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004259/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4259}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004260/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4260}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004261/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4261}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004262/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4262}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004263/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4263}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004264/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4264}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004265/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4265}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004266/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4266}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004267/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4267}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004268/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4268}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004269/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4269}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004270/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4270}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004271/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4271}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004272/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4272}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004273/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4273}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004274/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4274}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004275/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4275}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004276/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4276}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004277/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4277}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004278/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4278}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004279/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4279}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004280/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4280}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004281/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4281}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004282/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4282}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004283/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4283}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004284/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4284}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004285/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4285}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004286/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4286}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004287/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4287}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004288/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4288}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004289/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4289}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004290/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4290}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004291/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4291}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004292/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4292}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004293/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4293}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004294/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4294}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004295/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4295}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004296/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4296}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004297/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4297}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004298/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4298}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004299/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4299}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004300/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4300}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004301/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4301}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004302/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4302}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004303/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4303}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004304/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4304}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004305/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4305}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004306/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4306}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004307/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4307}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004308/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4308}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004309/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4309}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004310/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4310}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004311/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4311}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004312/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4312}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004313/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4313}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004314/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4314}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004315/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4315}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004316/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4316}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004317/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4317}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004318/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4318}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004319/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4319}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004320/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4320}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004321/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4321}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004322/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4322}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004323/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4323}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004324/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4324}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004325/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4325}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004326/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4326}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004327/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4327}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004328/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4328}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004329/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4329}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004330/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4330}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004331/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4331}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004332/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4332}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004333/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4333}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004334/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4334}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004335/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4335}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004336/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4336}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004337/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4337}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004338/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4338}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004339/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4339}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004340/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4340}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004341/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4341}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004342/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4342}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004343/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4343}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004344/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4344}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004345/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4345}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004346/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4346}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004347/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4347}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004348/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4348}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004349/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4349}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004350/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4350}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004351/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4351}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004352/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4352}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004353/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4353}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004354/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4354}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004355/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4355}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004356/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4356}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004357/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4357}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004358/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4358}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004359/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4359}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004360/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4360}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004361/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4361}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004362/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4362}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004363/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4363}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004364/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4364}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004365/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4365}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004366/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4366}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004367/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4367}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004368/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4368}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004369/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4369}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004370/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4370}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004371/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4371}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004372/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4372}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004373/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4373}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004374/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4374}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004375/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4375}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004376/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4376}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004377/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4377}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004378/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4378}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004379/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4379}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004380/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4380}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004381/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4381}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004382/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4382}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004383/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4383}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004384/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4384}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004385/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4385}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004386/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4386}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004387/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4387}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004388/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4388}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004389/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4389}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004390/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4390}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004391/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4391}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004392/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4392}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004393/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4393}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004394/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4394}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004395/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4395}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004396/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4396}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004397/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4397}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004398/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4398}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004399/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4399}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004400/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4400}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004401/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4401}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004402/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4402}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004403/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4403}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004404/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4404}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004405/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4405}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004406/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4406}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004407/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4407}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004408/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4408}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004409/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4409}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004410/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4410}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004411/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4411}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004412/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4412}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004413/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4413}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004414/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4414}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004415/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4415}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004416/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4416}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004417/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4417}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004418/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4418}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004419/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4419}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004420/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4420}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004421/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4421}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004422/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4422}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004423/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4423}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004424/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4424}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004425/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4425}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004426/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4426}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004427/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4427}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004428/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4428}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004429/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4429}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004430/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4430}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004431/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4431}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004432/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4432}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004433/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4433}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004434/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4434}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004435/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4435}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004436/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4436}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004437/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4437}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004438/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4438}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004439/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4439}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004440/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4440}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004441/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4441}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004442/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4442}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004443/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4443}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004444/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4444}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004445/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4445}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004446/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4446}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004447/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4447}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004448/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4448}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004449/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4449}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004450/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4450}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004451/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4451}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004452/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4452}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004453/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4453}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004454/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4454}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004455/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4455}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004456/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4456}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004457/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4457}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004458/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4458}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004459/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4459}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004460/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4460}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004461/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4461}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004462/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4462}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004463/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4463}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004464/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4464}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004465/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4465}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004466/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4466}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004467/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4467}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004468/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4468}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004469/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4469}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004470/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4470}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004471/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4471}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004472/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4472}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004473/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4473}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004474/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4474}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004475/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4475}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004476/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4476}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004477/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4477}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004478/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4478}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004479/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4479}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004480/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4480}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004481/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4481}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004482/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4482}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004483/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4483}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004484/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4484}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004485/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4485}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004486/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4486}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004487/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4487}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004488/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4488}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004489/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4489}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004490/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4490}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004491/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4491}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004492/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4492}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004493/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4493}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004494/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4494}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004495/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4495}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004496/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4496}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004497/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4497}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004498/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4498}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004499/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4499}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004500/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4500}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004501/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4501}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004502/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4502}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004503/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4503}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004504/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4504}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004505/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4505}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004506/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4506}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004507/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4507}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004508/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4508}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004509/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4509}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004510/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4510}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004511/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4511}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004512/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4512}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004513/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4513}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004514/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4514}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004515/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4515}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004516/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4516}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004517/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4517}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004518/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4518}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004519/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4519}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004520/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4520}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004521/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4521}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004522/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4522}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004523/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4523}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004524/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4524}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004525/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4525}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004526/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4526}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004527/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4527}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004528/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4528}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004529/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4529}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004530/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4530}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004531/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4531}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004532/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4532}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004533/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4533}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004534/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4534}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004535/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4535}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004536/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4536}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004537/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4537}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004538/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4538}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004539/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4539}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004540/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4540}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004541/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4541}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004542/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4542}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004543/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4543}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004544/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4544}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004545/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4545}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004546/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4546}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004547/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4547}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004548/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4548}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004549/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4549}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004550/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4550}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004551/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4551}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004552/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4552}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004553/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4553}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004554/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4554}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004555/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4555}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004556/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4556}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004557/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4557}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004558/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4558}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004559/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4559}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004560/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4560}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004561/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4561}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004562/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4562}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004563/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4563}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004564/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4564}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004565/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4565}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004566/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4566}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004567/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4567}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004568/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4568}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004569/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4569}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004570/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4570}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004571/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4571}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004572/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4572}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004573/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4573}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004574/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4574}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004575/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4575}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004576/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4576}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004577/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4577}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004578/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4578}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004579/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4579}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004580/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4580}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004581/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4581}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004582/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4582}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004583/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4583}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004584/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4584}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004585/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4585}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004586/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4586}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004587/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4587}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004588/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4588}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004589/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4589}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004590/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4590}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004591/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4591}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004592/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4592}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004593/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4593}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004594/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4594}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004595/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4595}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004596/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4596}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004597/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4597}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004598/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4598}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004599/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4599}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004600/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4600}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004601/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4601}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004602/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4602}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004603/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4603}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004604/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4604}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004605/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4605}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004606/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4606}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004607/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4607}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004608/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4608}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004609/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4609}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004610/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4610}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004611/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4611}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004612/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4612}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004613/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4613}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004614/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4614}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004615/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4615}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004616/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4616}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004617/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4617}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004618/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4618}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004619/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4619}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004620/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4620}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004621/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4621}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004622/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4622}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004623/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4623}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004624/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4624}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004625/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4625}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004626/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4626}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004627/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4627}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004628/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4628}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004629/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4629}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004630/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4630}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004631/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4631}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004632/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4632}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004633/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4633}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004634/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4634}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004635/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4635}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004636/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4636}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004637/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4637}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004638/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4638}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004639/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4639}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004640/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4640}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004641/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4641}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004642/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4642}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004643/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4643}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004644/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4644}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004645/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4645}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004646/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4646}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004647/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4647}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004648/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4648}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004649/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4649}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004650/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4650}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004651/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4651}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004652/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4652}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004653/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4653}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004654/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4654}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004655/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4655}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004656/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4656}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004657/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4657}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004658/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4658}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004659/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4659}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004660/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4660}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004661/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4661}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004662/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4662}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004663/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4663}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004664/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4664}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004665/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4665}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004666/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4666}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004667/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4667}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004668/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4668}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004669/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4669}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004670/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4670}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004671/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4671}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004672/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4672}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004673/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4673}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004674/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4674}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004675/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4675}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004676/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4676}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004677/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4677}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004678/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4678}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004679/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4679}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004680/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4680}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004681/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4681}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004682/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4682}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004683/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4683}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004684/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4684}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004685/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4685}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004686/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4686}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004687/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4687}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004688/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4688}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004689/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4689}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004690/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4690}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004691/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4691}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004692/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4692}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004693/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4693}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004694/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4694}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004695/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4695}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004696/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4696}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004697/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4697}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004698/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4698}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004699/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4699}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004700/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4700}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004701/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4701}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004702/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4702}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004703/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4703}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004704/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4704}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004705/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4705}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004706/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4706}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004707/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4707}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004708/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4708}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004709/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4709}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004710/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4710}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004711/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4711}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004712/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4712}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004713/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4713}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004714/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4714}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004715/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4715}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004716/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4716}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004717/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4717}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004718/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4718}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004719/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4719}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004720/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4720}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004721/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4721}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004722/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4722}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004723/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4723}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004724/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4724}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004725/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4725}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004726/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4726}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004727/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4727}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004728/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4728}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004729/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4729}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004730/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4730}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004731/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4731}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004732/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4732}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004733/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4733}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004734/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4734}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004735/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4735}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004736/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4736}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004737/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4737}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004738/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4738}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004739/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4739}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004740/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4740}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004741/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4741}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004742/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4742}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004743/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4743}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004744/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4744}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004745/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4745}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004746/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4746}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004747/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4747}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004748/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4748}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004749/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4749}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004750/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4750}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004751/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4751}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004752/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4752}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004753/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4753}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004754/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4754}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004755/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4755}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004756/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4756}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004757/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4757}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004758/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4758}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004759/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4759}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004760/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4760}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004761/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4761}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004762/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4762}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004763/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4763}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004764/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4764}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004765/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4765}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004766/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4766}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004767/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4767}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004768/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4768}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004769/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4769}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004770/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4770}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004771/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4771}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004772/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4772}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004773/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4773}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004774/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4774}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004775/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4775}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004776/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4776}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004777/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4777}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004778/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4778}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004779/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4779}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004780/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4780}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004781/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4781}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004782/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4782}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004783/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4783}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004784/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4784}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004785/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4785}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004786/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4786}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004787/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4787}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004788/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4788}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004789/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4789}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004790/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4790}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004791/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4791}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004792/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4792}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004793/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4793}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004794/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4794}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004795/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4795}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004796/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4796}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004797/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4797}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004798/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4798}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004799/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4799}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004800/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4800}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004801/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4801}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004802/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4802}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004803/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4803}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004804/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4804}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004805/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4805}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004806/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4806}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004807/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4807}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004808/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4808}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004809/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4809}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004810/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4810}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004811/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4811}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004812/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4812}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004813/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4813}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004814/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4814}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004815/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4815}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004816/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4816}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004817/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4817}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004818/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4818}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004819/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4819}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004820/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4820}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004821/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4821}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004822/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4822}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004823/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4823}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004824/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4824}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004825/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4825}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004826/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4826}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004827/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4827}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004828/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4828}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004829/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4829}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004830/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4830}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004831/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4831}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004832/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4832}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004833/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4833}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004834/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4834}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004835/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4835}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004836/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4836}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004837/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4837}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004838/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4838}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004839/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4839}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004840/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4840}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004841/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4841}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004842/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4842}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004843/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4843}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004844/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4844}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004845/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4845}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004846/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4846}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004847/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4847}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004848/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4848}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004849/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4849}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004850/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4850}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004851/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4851}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004852/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4852}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004853/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4853}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004854/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4854}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004855/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4855}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004856/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4856}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004857/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4857}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004858/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4858}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004859/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4859}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004860/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4860}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004861/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4861}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004862/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4862}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004863/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4863}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004864/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4864}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004865/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4865}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004866/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4866}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004867/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4867}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004868/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4868}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004869/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4869}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004870/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4870}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004871/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4871}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004872/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4872}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004873/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4873}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004874/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4874}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004875/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4875}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004876/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4876}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004877/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4877}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004878/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4878}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004879/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4879}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004880/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4880}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004881/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4881}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004882/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4882}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004883/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4883}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004884/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4884}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004885/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4885}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004886/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4886}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004887/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4887}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004888/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4888}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004889/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4889}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004890/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4890}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004891/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4891}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004892/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4892}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004893/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4893}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004894/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4894}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004895/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4895}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004896/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4896}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004897/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4897}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004898/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4898}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004899/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4899}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004900/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4900}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004901/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4901}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004902/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4902}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004903/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4903}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004904/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4904}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004905/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4905}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004906/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4906}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004907/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4907}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004908/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4908}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004909/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4909}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004910/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4910}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004911/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4911}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004912/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4912}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004913/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4913}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004914/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4914}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004915/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4915}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004916/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4916}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004917/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4917}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004918/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4918}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004919/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4919}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004920/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4920}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004921/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4921}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004922/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4922}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004923/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4923}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004924/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4924}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004925/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4925}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004926/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4926}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004927/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4927}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004928/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4928}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004929/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4929}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004930/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4930}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004931/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4931}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004932/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4932}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004933/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4933}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004934/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4934}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004935/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4935}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004936/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4936}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004937/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4937}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004938/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4938}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004939/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4939}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004940/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4940}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004941/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4941}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004942/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4942}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004943/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4943}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004944/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4944}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004945/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4945}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004946/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4946}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004947/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4947}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004948/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4948}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004949/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4949}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004950/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4950}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004951/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4951}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004952/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4952}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004953/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4953}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004954/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4954}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004955/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4955}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004956/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4956}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004957/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4957}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004958/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4958}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004959/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4959}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004960/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4960}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004961/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4961}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004962/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4962}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004963/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4963}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004964/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4964}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004965/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4965}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004966/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4966}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004967/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4967}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004968/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4968}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004969/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4969}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004970/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4970}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004971/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4971}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004972/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4972}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004973/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4973}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004974/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4974}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004975/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4975}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004976/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4976}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004977/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4977}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004978/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4978}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004979/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4979}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004980/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4980}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004981/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4981}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004982/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4982}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004983/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4983}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004984/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4984}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004985/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4985}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004986/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4986}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004987/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4987}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004988/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4988}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004989/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4989}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004990/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4990}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004991/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4991}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004992/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4992}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004993/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the final state, the final head location, and the key write/move sequence along the way. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4993}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004994/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4994}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004995/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. For each step, list what colour is written, the move (U/D/L/R), and the next state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4995}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004996/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. After running the steps, give where the head ends up (row, column) and which state qN the machine is in. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4996}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004997/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (which qN) and the final head position (row, column). Only modify what the task requires; keep the background and any other element unchanged.", "id": 4997}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004998/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Give the step-by-step execution: at each step the colour written, the move, and the resulting state. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4998}
+{"clip_path": "T090_turing_machine_grid_transition-data-generator/turing_machine_grid_transition_task/turing_machine_grid_transition_00004999/video/ground_truth.mp4", "text_annot": "A 2D Turing machine runs on the coloured grid: each cell's colour is its symbol, and the black dot is the read/write head, sitting on one cell at a (row, column) position. The machine is also in one of several states named q1, q2, q3, … — a state is the machine's internal mode, NOT a position on the grid. Each transition rule is written 'state, read-colour -> write-colour, move, next-state' and means: when the machine is in that state and the head reads that colour, it writes the new colour into the head's current cell, moves the head one cell (U/D/L/R = up/down/left/right), and switches to the next state. The board is finite: a move that would leave the grid is not taken and the machine stops. Start from the state and head position shown and run the number of steps given in the header. Report the final state (qN), the final head position (row, column), and a short summary of the writes and moves. Only modify what the task requires; keep the background and any other element unchanged.", "id": 4999}